Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * USB Audio Driver for ALSA
4 *
5 * Quirks and vendor-specific extensions for mixer interfaces
6 *
7 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
8 *
9 * Many codes borrowed from audio.c by
10 * Alan Cox (alan@lxorguk.ukuu.org.uk)
11 * Thomas Sailer (sailer@ife.ee.ethz.ch)
12 *
13 * Audio Advantage Micro II support added by:
14 * Przemek Rudy (prudy1@o2.pl)
15 */
16
17#include <linux/bitfield.h>
18#include <linux/hid.h>
19#include <linux/init.h>
20#include <linux/math64.h>
21#include <linux/slab.h>
22#include <linux/usb.h>
23#include <linux/usb/audio.h>
24
25#include <sound/asoundef.h>
26#include <sound/core.h>
27#include <sound/control.h>
28#include <sound/hda_verbs.h>
29#include <sound/hwdep.h>
30#include <sound/info.h>
31#include <sound/tlv.h>
32
33#include "usbaudio.h"
34#include "mixer.h"
35#include "mixer_quirks.h"
36#include "mixer_scarlett.h"
37#include "mixer_scarlett2.h"
38#include "mixer_us16x08.h"
39#include "mixer_s1810c.h"
40#include "helper.h"
41
42struct std_mono_table {
43 unsigned int unitid, control, cmask;
44 int val_type;
45 const char *name;
46 snd_kcontrol_tlv_rw_t *tlv_callback;
47};
48
49/* This function allows for the creation of standard UAC controls.
50 * See the quirks for M-Audio FTUs or Ebox-44.
51 * If you don't want to set a TLV callback pass NULL.
52 *
53 * Since there doesn't seem to be a devices that needs a multichannel
54 * version, we keep it mono for simplicity.
55 */
56static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
57 unsigned int unitid,
58 unsigned int control,
59 unsigned int cmask,
60 int val_type,
61 unsigned int idx_off,
62 const char *name,
63 snd_kcontrol_tlv_rw_t *tlv_callback)
64{
65 struct usb_mixer_elem_info *cval;
66 struct snd_kcontrol *kctl;
67
68 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
69 if (!cval)
70 return -ENOMEM;
71
72 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
73 cval->val_type = val_type;
74 cval->channels = 1;
75 cval->control = control;
76 cval->cmask = cmask;
77 cval->idx_off = idx_off;
78
79 /* get_min_max() is called only for integer volumes later,
80 * so provide a short-cut for booleans */
81 cval->min = 0;
82 cval->max = 1;
83 cval->res = 0;
84 cval->dBmin = 0;
85 cval->dBmax = 0;
86
87 /* Create control */
88 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
89 if (!kctl) {
90 kfree(cval);
91 return -ENOMEM;
92 }
93
94 /* Set name */
95 snprintf(kctl->id.name, sizeof(kctl->id.name), name);
96 kctl->private_free = snd_usb_mixer_elem_free;
97
98 /* set TLV */
99 if (tlv_callback) {
100 kctl->tlv.c = tlv_callback;
101 kctl->vd[0].access |=
102 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
103 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
104 }
105 /* Add control to mixer */
106 return snd_usb_mixer_add_control(&cval->head, kctl);
107}
108
109static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
110 unsigned int unitid,
111 unsigned int control,
112 unsigned int cmask,
113 int val_type,
114 const char *name,
115 snd_kcontrol_tlv_rw_t *tlv_callback)
116{
117 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
118 val_type, 0 /* Offset */, name, tlv_callback);
119}
120
121/*
122 * Create a set of standard UAC controls from a table
123 */
124static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
125 const struct std_mono_table *t)
126{
127 int err;
128
129 while (t->name != NULL) {
130 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
131 t->cmask, t->val_type, t->name, t->tlv_callback);
132 if (err < 0)
133 return err;
134 t++;
135 }
136
137 return 0;
138}
139
140static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer,
141 int id,
142 usb_mixer_elem_resume_func_t resume,
143 const struct snd_kcontrol_new *knew,
144 struct usb_mixer_elem_list **listp)
145{
146 struct usb_mixer_elem_list *list;
147 struct snd_kcontrol *kctl;
148
149 list = kzalloc(sizeof(*list), GFP_KERNEL);
150 if (!list)
151 return -ENOMEM;
152 if (listp)
153 *listp = list;
154 list->mixer = mixer;
155 list->id = id;
156 list->resume = resume;
157 kctl = snd_ctl_new1(knew, list);
158 if (!kctl) {
159 kfree(list);
160 return -ENOMEM;
161 }
162 kctl->private_free = snd_usb_mixer_elem_free;
163 /* don't use snd_usb_mixer_add_control() here, this is a special list element */
164 return snd_usb_mixer_add_list(list, kctl, false);
165}
166
167/*
168 * Sound Blaster remote control configuration
169 *
170 * format of remote control data:
171 * Extigy: xx 00
172 * Audigy 2 NX: 06 80 xx 00 00 00
173 * Live! 24-bit: 06 80 xx yy 22 83
174 */
175static const struct rc_config {
176 u32 usb_id;
177 u8 offset;
178 u8 length;
179 u8 packet_length;
180 u8 min_packet_length; /* minimum accepted length of the URB result */
181 u8 mute_mixer_id;
182 u32 mute_code;
183} rc_configs[] = {
184 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
185 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
186 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
187 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
188 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
189 { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
190 { USB_ID(0x041e, 0x3263), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
191 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
192};
193
194static void snd_usb_soundblaster_remote_complete(struct urb *urb)
195{
196 struct usb_mixer_interface *mixer = urb->context;
197 const struct rc_config *rc = mixer->rc_cfg;
198 u32 code;
199
200 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
201 return;
202
203 code = mixer->rc_buffer[rc->offset];
204 if (rc->length == 2)
205 code |= mixer->rc_buffer[rc->offset + 1] << 8;
206
207 /* the Mute button actually changes the mixer control */
208 if (code == rc->mute_code)
209 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
210 mixer->rc_code = code;
211 wmb();
212 wake_up(&mixer->rc_waitq);
213}
214
215static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
216 long count, loff_t *offset)
217{
218 struct usb_mixer_interface *mixer = hw->private_data;
219 int err;
220 u32 rc_code;
221
222 if (count != 1 && count != 4)
223 return -EINVAL;
224 err = wait_event_interruptible(mixer->rc_waitq,
225 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
226 if (err == 0) {
227 if (count == 1)
228 err = put_user(rc_code, buf);
229 else
230 err = put_user(rc_code, (u32 __user *)buf);
231 }
232 return err < 0 ? err : count;
233}
234
235static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
236 poll_table *wait)
237{
238 struct usb_mixer_interface *mixer = hw->private_data;
239
240 poll_wait(file, &mixer->rc_waitq, wait);
241 return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0;
242}
243
244static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
245{
246 struct snd_hwdep *hwdep;
247 int err, len, i;
248
249 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
250 if (rc_configs[i].usb_id == mixer->chip->usb_id)
251 break;
252 if (i >= ARRAY_SIZE(rc_configs))
253 return 0;
254 mixer->rc_cfg = &rc_configs[i];
255
256 len = mixer->rc_cfg->packet_length;
257
258 init_waitqueue_head(&mixer->rc_waitq);
259 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
260 if (err < 0)
261 return err;
262 snprintf(hwdep->name, sizeof(hwdep->name),
263 "%s remote control", mixer->chip->card->shortname);
264 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
265 hwdep->private_data = mixer;
266 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
267 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
268 hwdep->exclusive = 1;
269
270 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
271 if (!mixer->rc_urb)
272 return -ENOMEM;
273 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
274 if (!mixer->rc_setup_packet) {
275 usb_free_urb(mixer->rc_urb);
276 mixer->rc_urb = NULL;
277 return -ENOMEM;
278 }
279 mixer->rc_setup_packet->bRequestType =
280 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
281 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
282 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
283 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
284 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
285 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
286 usb_rcvctrlpipe(mixer->chip->dev, 0),
287 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
288 snd_usb_soundblaster_remote_complete, mixer);
289 return 0;
290}
291
292#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
293
294static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
295{
296 ucontrol->value.integer.value[0] = kcontrol->private_value >> 8;
297 return 0;
298}
299
300static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer,
301 int value, int index)
302{
303 struct snd_usb_audio *chip = mixer->chip;
304 int err;
305
306 err = snd_usb_lock_shutdown(chip);
307 if (err < 0)
308 return err;
309
310 if (chip->usb_id == USB_ID(0x041e, 0x3042))
311 err = snd_usb_ctl_msg(chip->dev,
312 usb_sndctrlpipe(chip->dev, 0), 0x24,
313 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
314 !value, 0, NULL, 0);
315 /* USB X-Fi S51 Pro */
316 if (chip->usb_id == USB_ID(0x041e, 0x30df))
317 err = snd_usb_ctl_msg(chip->dev,
318 usb_sndctrlpipe(chip->dev, 0), 0x24,
319 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
320 !value, 0, NULL, 0);
321 else
322 err = snd_usb_ctl_msg(chip->dev,
323 usb_sndctrlpipe(chip->dev, 0), 0x24,
324 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
325 value, index + 2, NULL, 0);
326 snd_usb_unlock_shutdown(chip);
327 return err;
328}
329
330static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol,
331 struct snd_ctl_elem_value *ucontrol)
332{
333 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
334 struct usb_mixer_interface *mixer = list->mixer;
335 int index = kcontrol->private_value & 0xff;
336 unsigned int value = ucontrol->value.integer.value[0];
337 int old_value = kcontrol->private_value >> 8;
338 int err;
339
340 if (value > 1)
341 return -EINVAL;
342 if (value == old_value)
343 return 0;
344 kcontrol->private_value = (value << 8) | index;
345 err = snd_audigy2nx_led_update(mixer, value, index);
346 return err < 0 ? err : 1;
347}
348
349static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list)
350{
351 int priv_value = list->kctl->private_value;
352
353 return snd_audigy2nx_led_update(list->mixer, priv_value >> 8,
354 priv_value & 0xff);
355}
356
357/* name and private_value are set dynamically */
358static const struct snd_kcontrol_new snd_audigy2nx_control = {
359 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
360 .info = snd_audigy2nx_led_info,
361 .get = snd_audigy2nx_led_get,
362 .put = snd_audigy2nx_led_put,
363};
364
365static const char * const snd_audigy2nx_led_names[] = {
366 "CMSS LED Switch",
367 "Power LED Switch",
368 "Dolby Digital LED Switch",
369};
370
371static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
372{
373 int i, err;
374
375 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) {
376 struct snd_kcontrol_new knew;
377
378 /* USB X-Fi S51 doesn't have a CMSS LED */
379 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
380 continue;
381 /* USB X-Fi S51 Pro doesn't have one either */
382 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
383 continue;
384 if (i > 1 && /* Live24ext has 2 LEDs only */
385 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
386 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
387 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
388 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
389 break;
390
391 knew = snd_audigy2nx_control;
392 knew.name = snd_audigy2nx_led_names[i];
393 knew.private_value = (1 << 8) | i; /* LED on as default */
394 err = add_single_ctl_with_resume(mixer, 0,
395 snd_audigy2nx_led_resume,
396 &knew, NULL);
397 if (err < 0)
398 return err;
399 }
400 return 0;
401}
402
403static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
404 struct snd_info_buffer *buffer)
405{
406 static const struct sb_jack {
407 int unitid;
408 const char *name;
409 } jacks_audigy2nx[] = {
410 {4, "dig in "},
411 {7, "line in"},
412 {19, "spk out"},
413 {20, "hph out"},
414 {-1, NULL}
415 }, jacks_live24ext[] = {
416 {4, "line in"}, /* &1=Line, &2=Mic*/
417 {3, "hph out"}, /* headphones */
418 {0, "RC "}, /* last command, 6 bytes see rc_config above */
419 {-1, NULL}
420 };
421 const struct sb_jack *jacks;
422 struct usb_mixer_interface *mixer = entry->private_data;
423 int i, err;
424 u8 buf[3];
425
426 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
427 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
428 jacks = jacks_audigy2nx;
429 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
430 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
431 jacks = jacks_live24ext;
432 else
433 return;
434
435 for (i = 0; jacks[i].name; ++i) {
436 snd_iprintf(buffer, "%s: ", jacks[i].name);
437 err = snd_usb_lock_shutdown(mixer->chip);
438 if (err < 0)
439 return;
440 err = snd_usb_ctl_msg(mixer->chip->dev,
441 usb_rcvctrlpipe(mixer->chip->dev, 0),
442 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
443 USB_RECIP_INTERFACE, 0,
444 jacks[i].unitid << 8, buf, 3);
445 snd_usb_unlock_shutdown(mixer->chip);
446 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
447 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
448 else
449 snd_iprintf(buffer, "?\n");
450 }
451}
452
453/* EMU0204 */
454static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
455 struct snd_ctl_elem_info *uinfo)
456{
457 static const char * const texts[2] = {"1/2", "3/4"};
458
459 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
460}
461
462static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
463 struct snd_ctl_elem_value *ucontrol)
464{
465 ucontrol->value.enumerated.item[0] = kcontrol->private_value;
466 return 0;
467}
468
469static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer,
470 int value)
471{
472 struct snd_usb_audio *chip = mixer->chip;
473 int err;
474 unsigned char buf[2];
475
476 err = snd_usb_lock_shutdown(chip);
477 if (err < 0)
478 return err;
479
480 buf[0] = 0x01;
481 buf[1] = value ? 0x02 : 0x01;
482 err = snd_usb_ctl_msg(chip->dev,
483 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
484 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
485 0x0400, 0x0e00, buf, 2);
486 snd_usb_unlock_shutdown(chip);
487 return err;
488}
489
490static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
491 struct snd_ctl_elem_value *ucontrol)
492{
493 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
494 struct usb_mixer_interface *mixer = list->mixer;
495 unsigned int value = ucontrol->value.enumerated.item[0];
496 int err;
497
498 if (value > 1)
499 return -EINVAL;
500
501 if (value == kcontrol->private_value)
502 return 0;
503
504 kcontrol->private_value = value;
505 err = snd_emu0204_ch_switch_update(mixer, value);
506 return err < 0 ? err : 1;
507}
508
509static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list)
510{
511 return snd_emu0204_ch_switch_update(list->mixer,
512 list->kctl->private_value);
513}
514
515static const struct snd_kcontrol_new snd_emu0204_control = {
516 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
517 .name = "Front Jack Channels",
518 .info = snd_emu0204_ch_switch_info,
519 .get = snd_emu0204_ch_switch_get,
520 .put = snd_emu0204_ch_switch_put,
521 .private_value = 0,
522};
523
524static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
525{
526 return add_single_ctl_with_resume(mixer, 0,
527 snd_emu0204_ch_switch_resume,
528 &snd_emu0204_control, NULL);
529}
530
531/* ASUS Xonar U1 / U3 controls */
532
533static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
534 struct snd_ctl_elem_value *ucontrol)
535{
536 ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02);
537 return 0;
538}
539
540static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer,
541 unsigned char status)
542{
543 struct snd_usb_audio *chip = mixer->chip;
544 int err;
545
546 err = snd_usb_lock_shutdown(chip);
547 if (err < 0)
548 return err;
549 err = snd_usb_ctl_msg(chip->dev,
550 usb_sndctrlpipe(chip->dev, 0), 0x08,
551 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
552 50, 0, &status, 1);
553 snd_usb_unlock_shutdown(chip);
554 return err;
555}
556
557static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
558 struct snd_ctl_elem_value *ucontrol)
559{
560 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
561 u8 old_status, new_status;
562 int err;
563
564 old_status = kcontrol->private_value;
565 if (ucontrol->value.integer.value[0])
566 new_status = old_status | 0x02;
567 else
568 new_status = old_status & ~0x02;
569 if (new_status == old_status)
570 return 0;
571
572 kcontrol->private_value = new_status;
573 err = snd_xonar_u1_switch_update(list->mixer, new_status);
574 return err < 0 ? err : 1;
575}
576
577static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list)
578{
579 return snd_xonar_u1_switch_update(list->mixer,
580 list->kctl->private_value);
581}
582
583static const struct snd_kcontrol_new snd_xonar_u1_output_switch = {
584 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
585 .name = "Digital Playback Switch",
586 .info = snd_ctl_boolean_mono_info,
587 .get = snd_xonar_u1_switch_get,
588 .put = snd_xonar_u1_switch_put,
589 .private_value = 0x05,
590};
591
592static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
593{
594 return add_single_ctl_with_resume(mixer, 0,
595 snd_xonar_u1_switch_resume,
596 &snd_xonar_u1_output_switch, NULL);
597}
598
599/* Digidesign Mbox 1 helper functions */
600
601static int snd_mbox1_is_spdif_synced(struct snd_usb_audio *chip)
602{
603 unsigned char buff[3];
604 int err;
605 int is_spdif_synced;
606
607 /* Read clock source */
608 err = snd_usb_ctl_msg(chip->dev,
609 usb_rcvctrlpipe(chip->dev, 0), 0x81,
610 USB_DIR_IN |
611 USB_TYPE_CLASS |
612 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
613 if (err < 0)
614 return err;
615
616 /* spdif sync: buff is all zeroes */
617 is_spdif_synced = !(buff[0] | buff[1] | buff[2]);
618 return is_spdif_synced;
619}
620
621static int snd_mbox1_set_clk_source(struct snd_usb_audio *chip, int rate_or_zero)
622{
623 /* 2 possibilities: Internal -> expects sample rate
624 * S/PDIF sync -> expects rate = 0
625 */
626 unsigned char buff[3];
627
628 buff[0] = (rate_or_zero >> 0) & 0xff;
629 buff[1] = (rate_or_zero >> 8) & 0xff;
630 buff[2] = (rate_or_zero >> 16) & 0xff;
631
632 /* Set clock source */
633 return snd_usb_ctl_msg(chip->dev,
634 usb_sndctrlpipe(chip->dev, 0), 0x1,
635 USB_TYPE_CLASS |
636 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
637}
638
639static int snd_mbox1_is_spdif_input(struct snd_usb_audio *chip)
640{
641 /* Hardware gives 2 possibilities: ANALOG Source -> 0x01
642 * S/PDIF Source -> 0x02
643 */
644 int err;
645 unsigned char source[1];
646
647 /* Read input source */
648 err = snd_usb_ctl_msg(chip->dev,
649 usb_rcvctrlpipe(chip->dev, 0), 0x81,
650 USB_DIR_IN |
651 USB_TYPE_CLASS |
652 USB_RECIP_INTERFACE, 0x00, 0x500, source, 1);
653 if (err < 0)
654 return err;
655
656 return (source[0] == 2);
657}
658
659static int snd_mbox1_set_input_source(struct snd_usb_audio *chip, int is_spdif)
660{
661 /* NB: Setting the input source to S/PDIF resets the clock source to S/PDIF
662 * Hardware expects 2 possibilities: ANALOG Source -> 0x01
663 * S/PDIF Source -> 0x02
664 */
665 unsigned char buff[1];
666
667 buff[0] = (is_spdif & 1) + 1;
668
669 /* Set input source */
670 return snd_usb_ctl_msg(chip->dev,
671 usb_sndctrlpipe(chip->dev, 0), 0x1,
672 USB_TYPE_CLASS |
673 USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1);
674}
675
676/* Digidesign Mbox 1 clock source switch (internal/spdif) */
677
678static int snd_mbox1_clk_switch_get(struct snd_kcontrol *kctl,
679 struct snd_ctl_elem_value *ucontrol)
680{
681 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
682 struct snd_usb_audio *chip = list->mixer->chip;
683 int err;
684
685 err = snd_usb_lock_shutdown(chip);
686 if (err < 0)
687 goto err;
688
689 err = snd_mbox1_is_spdif_synced(chip);
690 if (err < 0)
691 goto err;
692
693 kctl->private_value = err;
694 err = 0;
695 ucontrol->value.enumerated.item[0] = kctl->private_value;
696err:
697 snd_usb_unlock_shutdown(chip);
698 return err;
699}
700
701static int snd_mbox1_clk_switch_update(struct usb_mixer_interface *mixer, int is_spdif_sync)
702{
703 struct snd_usb_audio *chip = mixer->chip;
704 int err;
705
706 err = snd_usb_lock_shutdown(chip);
707 if (err < 0)
708 return err;
709
710 err = snd_mbox1_is_spdif_input(chip);
711 if (err < 0)
712 goto err;
713
714 err = snd_mbox1_is_spdif_synced(chip);
715 if (err < 0)
716 goto err;
717
718 /* FIXME: hardcoded sample rate */
719 err = snd_mbox1_set_clk_source(chip, is_spdif_sync ? 0 : 48000);
720 if (err < 0)
721 goto err;
722
723 err = snd_mbox1_is_spdif_synced(chip);
724err:
725 snd_usb_unlock_shutdown(chip);
726 return err;
727}
728
729static int snd_mbox1_clk_switch_put(struct snd_kcontrol *kctl,
730 struct snd_ctl_elem_value *ucontrol)
731{
732 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
733 struct usb_mixer_interface *mixer = list->mixer;
734 int err;
735 bool cur_val, new_val;
736
737 cur_val = kctl->private_value;
738 new_val = ucontrol->value.enumerated.item[0];
739 if (cur_val == new_val)
740 return 0;
741
742 kctl->private_value = new_val;
743 err = snd_mbox1_clk_switch_update(mixer, new_val);
744 return err < 0 ? err : 1;
745}
746
747static int snd_mbox1_clk_switch_info(struct snd_kcontrol *kcontrol,
748 struct snd_ctl_elem_info *uinfo)
749{
750 static const char *const texts[2] = {
751 "Internal",
752 "S/PDIF"
753 };
754
755 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
756}
757
758static int snd_mbox1_clk_switch_resume(struct usb_mixer_elem_list *list)
759{
760 return snd_mbox1_clk_switch_update(list->mixer, list->kctl->private_value);
761}
762
763/* Digidesign Mbox 1 input source switch (analog/spdif) */
764
765static int snd_mbox1_src_switch_get(struct snd_kcontrol *kctl,
766 struct snd_ctl_elem_value *ucontrol)
767{
768 ucontrol->value.enumerated.item[0] = kctl->private_value;
769 return 0;
770}
771
772static int snd_mbox1_src_switch_update(struct usb_mixer_interface *mixer, int is_spdif_input)
773{
774 struct snd_usb_audio *chip = mixer->chip;
775 int err;
776
777 err = snd_usb_lock_shutdown(chip);
778 if (err < 0)
779 return err;
780
781 err = snd_mbox1_is_spdif_input(chip);
782 if (err < 0)
783 goto err;
784
785 err = snd_mbox1_set_input_source(chip, is_spdif_input);
786 if (err < 0)
787 goto err;
788
789 err = snd_mbox1_is_spdif_input(chip);
790 if (err < 0)
791 goto err;
792
793 err = snd_mbox1_is_spdif_synced(chip);
794err:
795 snd_usb_unlock_shutdown(chip);
796 return err;
797}
798
799static int snd_mbox1_src_switch_put(struct snd_kcontrol *kctl,
800 struct snd_ctl_elem_value *ucontrol)
801{
802 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
803 struct usb_mixer_interface *mixer = list->mixer;
804 int err;
805 bool cur_val, new_val;
806
807 cur_val = kctl->private_value;
808 new_val = ucontrol->value.enumerated.item[0];
809 if (cur_val == new_val)
810 return 0;
811
812 kctl->private_value = new_val;
813 err = snd_mbox1_src_switch_update(mixer, new_val);
814 return err < 0 ? err : 1;
815}
816
817static int snd_mbox1_src_switch_info(struct snd_kcontrol *kcontrol,
818 struct snd_ctl_elem_info *uinfo)
819{
820 static const char *const texts[2] = {
821 "Analog",
822 "S/PDIF"
823 };
824
825 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
826}
827
828static int snd_mbox1_src_switch_resume(struct usb_mixer_elem_list *list)
829{
830 return snd_mbox1_src_switch_update(list->mixer, list->kctl->private_value);
831}
832
833static const struct snd_kcontrol_new snd_mbox1_clk_switch = {
834 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
835 .name = "Clock Source",
836 .index = 0,
837 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
838 .info = snd_mbox1_clk_switch_info,
839 .get = snd_mbox1_clk_switch_get,
840 .put = snd_mbox1_clk_switch_put,
841 .private_value = 0
842};
843
844static const struct snd_kcontrol_new snd_mbox1_src_switch = {
845 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
846 .name = "Input Source",
847 .index = 1,
848 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
849 .info = snd_mbox1_src_switch_info,
850 .get = snd_mbox1_src_switch_get,
851 .put = snd_mbox1_src_switch_put,
852 .private_value = 0
853};
854
855static int snd_mbox1_controls_create(struct usb_mixer_interface *mixer)
856{
857 int err;
858 err = add_single_ctl_with_resume(mixer, 0,
859 snd_mbox1_clk_switch_resume,
860 &snd_mbox1_clk_switch, NULL);
861 if (err < 0)
862 return err;
863
864 return add_single_ctl_with_resume(mixer, 1,
865 snd_mbox1_src_switch_resume,
866 &snd_mbox1_src_switch, NULL);
867}
868
869/* Native Instruments device quirks */
870
871#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
872
873static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
874 struct snd_kcontrol *kctl)
875{
876 struct usb_device *dev = mixer->chip->dev;
877 unsigned int pval = kctl->private_value;
878 u8 value;
879 int err;
880
881 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
882 (pval >> 16) & 0xff,
883 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
884 0, pval & 0xffff, &value, 1);
885 if (err < 0) {
886 dev_err(&dev->dev,
887 "unable to issue vendor read request (ret = %d)", err);
888 return err;
889 }
890
891 kctl->private_value |= ((unsigned int)value << 24);
892 return 0;
893}
894
895static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
896 struct snd_ctl_elem_value *ucontrol)
897{
898 ucontrol->value.integer.value[0] = kcontrol->private_value >> 24;
899 return 0;
900}
901
902static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list)
903{
904 struct snd_usb_audio *chip = list->mixer->chip;
905 unsigned int pval = list->kctl->private_value;
906 int err;
907
908 err = snd_usb_lock_shutdown(chip);
909 if (err < 0)
910 return err;
911 err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
912 (pval >> 16) & 0xff,
913 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
914 pval >> 24, pval & 0xffff, NULL, 0, 1000);
915 snd_usb_unlock_shutdown(chip);
916 return err;
917}
918
919static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
920 struct snd_ctl_elem_value *ucontrol)
921{
922 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
923 u8 oldval = (kcontrol->private_value >> 24) & 0xff;
924 u8 newval = ucontrol->value.integer.value[0];
925 int err;
926
927 if (oldval == newval)
928 return 0;
929
930 kcontrol->private_value &= ~(0xff << 24);
931 kcontrol->private_value |= (unsigned int)newval << 24;
932 err = snd_ni_update_cur_val(list);
933 return err < 0 ? err : 1;
934}
935
936static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
937 {
938 .name = "Direct Thru Channel A",
939 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
940 },
941 {
942 .name = "Direct Thru Channel B",
943 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
944 },
945 {
946 .name = "Phono Input Channel A",
947 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
948 },
949 {
950 .name = "Phono Input Channel B",
951 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
952 },
953};
954
955static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
956 {
957 .name = "Direct Thru Channel A",
958 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
959 },
960 {
961 .name = "Direct Thru Channel B",
962 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
963 },
964 {
965 .name = "Direct Thru Channel C",
966 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
967 },
968 {
969 .name = "Direct Thru Channel D",
970 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
971 },
972 {
973 .name = "Phono Input Channel A",
974 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
975 },
976 {
977 .name = "Phono Input Channel B",
978 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
979 },
980 {
981 .name = "Phono Input Channel C",
982 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
983 },
984 {
985 .name = "Phono Input Channel D",
986 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
987 },
988};
989
990static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
991 const struct snd_kcontrol_new *kc,
992 unsigned int count)
993{
994 int i, err = 0;
995 struct snd_kcontrol_new template = {
996 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
997 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
998 .get = snd_nativeinstruments_control_get,
999 .put = snd_nativeinstruments_control_put,
1000 .info = snd_ctl_boolean_mono_info,
1001 };
1002
1003 for (i = 0; i < count; i++) {
1004 struct usb_mixer_elem_list *list;
1005
1006 template.name = kc[i].name;
1007 template.private_value = kc[i].private_value;
1008
1009 err = add_single_ctl_with_resume(mixer, 0,
1010 snd_ni_update_cur_val,
1011 &template, &list);
1012 if (err < 0)
1013 break;
1014 snd_ni_control_init_val(mixer, list->kctl);
1015 }
1016
1017 return err;
1018}
1019
1020/* M-Audio FastTrack Ultra quirks */
1021/* FTU Effect switch (also used by C400/C600) */
1022static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
1023 struct snd_ctl_elem_info *uinfo)
1024{
1025 static const char *const texts[8] = {
1026 "Room 1", "Room 2", "Room 3", "Hall 1",
1027 "Hall 2", "Plate", "Delay", "Echo"
1028 };
1029
1030 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1031}
1032
1033static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
1034 struct snd_kcontrol *kctl)
1035{
1036 struct usb_device *dev = mixer->chip->dev;
1037 unsigned int pval = kctl->private_value;
1038 int err;
1039 unsigned char value[2];
1040
1041 value[0] = 0x00;
1042 value[1] = 0x00;
1043
1044 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
1045 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1046 pval & 0xff00,
1047 snd_usb_ctrl_intf(mixer->hostif) | ((pval & 0xff) << 8),
1048 value, 2);
1049 if (err < 0)
1050 return err;
1051
1052 kctl->private_value |= (unsigned int)value[0] << 24;
1053 return 0;
1054}
1055
1056static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
1057 struct snd_ctl_elem_value *ucontrol)
1058{
1059 ucontrol->value.enumerated.item[0] = kctl->private_value >> 24;
1060 return 0;
1061}
1062
1063static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list)
1064{
1065 struct snd_usb_audio *chip = list->mixer->chip;
1066 unsigned int pval = list->kctl->private_value;
1067 unsigned char value[2];
1068 int err;
1069
1070 value[0] = pval >> 24;
1071 value[1] = 0;
1072
1073 err = snd_usb_lock_shutdown(chip);
1074 if (err < 0)
1075 return err;
1076 err = snd_usb_ctl_msg(chip->dev,
1077 usb_sndctrlpipe(chip->dev, 0),
1078 UAC_SET_CUR,
1079 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1080 pval & 0xff00,
1081 snd_usb_ctrl_intf(list->mixer->hostif) | ((pval & 0xff) << 8),
1082 value, 2);
1083 snd_usb_unlock_shutdown(chip);
1084 return err;
1085}
1086
1087static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
1088 struct snd_ctl_elem_value *ucontrol)
1089{
1090 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
1091 unsigned int pval = list->kctl->private_value;
1092 int cur_val, err, new_val;
1093
1094 cur_val = pval >> 24;
1095 new_val = ucontrol->value.enumerated.item[0];
1096 if (cur_val == new_val)
1097 return 0;
1098
1099 kctl->private_value &= ~(0xff << 24);
1100 kctl->private_value |= new_val << 24;
1101 err = snd_ftu_eff_switch_update(list);
1102 return err < 0 ? err : 1;
1103}
1104
1105static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
1106 int validx, int bUnitID)
1107{
1108 static struct snd_kcontrol_new template = {
1109 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1110 .name = "Effect Program Switch",
1111 .index = 0,
1112 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1113 .info = snd_ftu_eff_switch_info,
1114 .get = snd_ftu_eff_switch_get,
1115 .put = snd_ftu_eff_switch_put
1116 };
1117 struct usb_mixer_elem_list *list;
1118 int err;
1119
1120 err = add_single_ctl_with_resume(mixer, bUnitID,
1121 snd_ftu_eff_switch_update,
1122 &template, &list);
1123 if (err < 0)
1124 return err;
1125 list->kctl->private_value = (validx << 8) | bUnitID;
1126 snd_ftu_eff_switch_init(mixer, list->kctl);
1127 return 0;
1128}
1129
1130/* Create volume controls for FTU devices*/
1131static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
1132{
1133 char name[64];
1134 unsigned int control, cmask;
1135 int in, out, err;
1136
1137 const unsigned int id = 5;
1138 const int val_type = USB_MIXER_S16;
1139
1140 for (out = 0; out < 8; out++) {
1141 control = out + 1;
1142 for (in = 0; in < 8; in++) {
1143 cmask = BIT(in);
1144 snprintf(name, sizeof(name),
1145 "AIn%d - Out%d Capture Volume",
1146 in + 1, out + 1);
1147 err = snd_create_std_mono_ctl(mixer, id, control,
1148 cmask, val_type, name,
1149 &snd_usb_mixer_vol_tlv);
1150 if (err < 0)
1151 return err;
1152 }
1153 for (in = 8; in < 16; in++) {
1154 cmask = BIT(in);
1155 snprintf(name, sizeof(name),
1156 "DIn%d - Out%d Playback Volume",
1157 in - 7, out + 1);
1158 err = snd_create_std_mono_ctl(mixer, id, control,
1159 cmask, val_type, name,
1160 &snd_usb_mixer_vol_tlv);
1161 if (err < 0)
1162 return err;
1163 }
1164 }
1165
1166 return 0;
1167}
1168
1169/* This control needs a volume quirk, see mixer.c */
1170static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1171{
1172 static const char name[] = "Effect Volume";
1173 const unsigned int id = 6;
1174 const int val_type = USB_MIXER_U8;
1175 const unsigned int control = 2;
1176 const unsigned int cmask = 0;
1177
1178 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1179 name, snd_usb_mixer_vol_tlv);
1180}
1181
1182/* This control needs a volume quirk, see mixer.c */
1183static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1184{
1185 static const char name[] = "Effect Duration";
1186 const unsigned int id = 6;
1187 const int val_type = USB_MIXER_S16;
1188 const unsigned int control = 3;
1189 const unsigned int cmask = 0;
1190
1191 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1192 name, snd_usb_mixer_vol_tlv);
1193}
1194
1195/* This control needs a volume quirk, see mixer.c */
1196static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1197{
1198 static const char name[] = "Effect Feedback Volume";
1199 const unsigned int id = 6;
1200 const int val_type = USB_MIXER_U8;
1201 const unsigned int control = 4;
1202 const unsigned int cmask = 0;
1203
1204 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1205 name, NULL);
1206}
1207
1208static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1209{
1210 unsigned int cmask;
1211 int err, ch;
1212 char name[48];
1213
1214 const unsigned int id = 7;
1215 const int val_type = USB_MIXER_S16;
1216 const unsigned int control = 7;
1217
1218 for (ch = 0; ch < 4; ++ch) {
1219 cmask = BIT(ch);
1220 snprintf(name, sizeof(name),
1221 "Effect Return %d Volume", ch + 1);
1222 err = snd_create_std_mono_ctl(mixer, id, control,
1223 cmask, val_type, name,
1224 snd_usb_mixer_vol_tlv);
1225 if (err < 0)
1226 return err;
1227 }
1228
1229 return 0;
1230}
1231
1232static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1233{
1234 unsigned int cmask;
1235 int err, ch;
1236 char name[48];
1237
1238 const unsigned int id = 5;
1239 const int val_type = USB_MIXER_S16;
1240 const unsigned int control = 9;
1241
1242 for (ch = 0; ch < 8; ++ch) {
1243 cmask = BIT(ch);
1244 snprintf(name, sizeof(name),
1245 "Effect Send AIn%d Volume", ch + 1);
1246 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1247 val_type, name,
1248 snd_usb_mixer_vol_tlv);
1249 if (err < 0)
1250 return err;
1251 }
1252 for (ch = 8; ch < 16; ++ch) {
1253 cmask = BIT(ch);
1254 snprintf(name, sizeof(name),
1255 "Effect Send DIn%d Volume", ch - 7);
1256 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1257 val_type, name,
1258 snd_usb_mixer_vol_tlv);
1259 if (err < 0)
1260 return err;
1261 }
1262 return 0;
1263}
1264
1265static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1266{
1267 int err;
1268
1269 err = snd_ftu_create_volume_ctls(mixer);
1270 if (err < 0)
1271 return err;
1272
1273 err = snd_ftu_create_effect_switch(mixer, 1, 6);
1274 if (err < 0)
1275 return err;
1276
1277 err = snd_ftu_create_effect_volume_ctl(mixer);
1278 if (err < 0)
1279 return err;
1280
1281 err = snd_ftu_create_effect_duration_ctl(mixer);
1282 if (err < 0)
1283 return err;
1284
1285 err = snd_ftu_create_effect_feedback_ctl(mixer);
1286 if (err < 0)
1287 return err;
1288
1289 err = snd_ftu_create_effect_return_ctls(mixer);
1290 if (err < 0)
1291 return err;
1292
1293 err = snd_ftu_create_effect_send_ctls(mixer);
1294 if (err < 0)
1295 return err;
1296
1297 return 0;
1298}
1299
1300void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1301 unsigned char samplerate_id)
1302{
1303 struct usb_mixer_interface *mixer;
1304 struct usb_mixer_elem_info *cval;
1305 int unitid = 12; /* SampleRate ExtensionUnit ID */
1306
1307 list_for_each_entry(mixer, &chip->mixer_list, list) {
1308 if (mixer->id_elems[unitid]) {
1309 cval = mixer_elem_list_to_info(mixer->id_elems[unitid]);
1310 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1311 cval->control << 8,
1312 samplerate_id);
1313 snd_usb_mixer_notify_id(mixer, unitid);
1314 break;
1315 }
1316 }
1317}
1318
1319/* M-Audio Fast Track C400/C600 */
1320/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1321static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1322{
1323 char name[64];
1324 unsigned int cmask, offset;
1325 int out, chan, err;
1326 int num_outs = 0;
1327 int num_ins = 0;
1328
1329 const unsigned int id = 0x40;
1330 const int val_type = USB_MIXER_S16;
1331 const int control = 1;
1332
1333 switch (mixer->chip->usb_id) {
1334 case USB_ID(0x0763, 0x2030):
1335 num_outs = 6;
1336 num_ins = 4;
1337 break;
1338 case USB_ID(0x0763, 0x2031):
1339 num_outs = 8;
1340 num_ins = 6;
1341 break;
1342 }
1343
1344 for (chan = 0; chan < num_outs + num_ins; chan++) {
1345 for (out = 0; out < num_outs; out++) {
1346 if (chan < num_outs) {
1347 snprintf(name, sizeof(name),
1348 "PCM%d-Out%d Playback Volume",
1349 chan + 1, out + 1);
1350 } else {
1351 snprintf(name, sizeof(name),
1352 "In%d-Out%d Playback Volume",
1353 chan - num_outs + 1, out + 1);
1354 }
1355
1356 cmask = (out == 0) ? 0 : BIT(out - 1);
1357 offset = chan * num_outs;
1358 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1359 cmask, val_type, offset, name,
1360 &snd_usb_mixer_vol_tlv);
1361 if (err < 0)
1362 return err;
1363 }
1364 }
1365
1366 return 0;
1367}
1368
1369/* This control needs a volume quirk, see mixer.c */
1370static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1371{
1372 static const char name[] = "Effect Volume";
1373 const unsigned int id = 0x43;
1374 const int val_type = USB_MIXER_U8;
1375 const unsigned int control = 3;
1376 const unsigned int cmask = 0;
1377
1378 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1379 name, snd_usb_mixer_vol_tlv);
1380}
1381
1382/* This control needs a volume quirk, see mixer.c */
1383static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1384{
1385 static const char name[] = "Effect Duration";
1386 const unsigned int id = 0x43;
1387 const int val_type = USB_MIXER_S16;
1388 const unsigned int control = 4;
1389 const unsigned int cmask = 0;
1390
1391 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1392 name, snd_usb_mixer_vol_tlv);
1393}
1394
1395/* This control needs a volume quirk, see mixer.c */
1396static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1397{
1398 static const char name[] = "Effect Feedback Volume";
1399 const unsigned int id = 0x43;
1400 const int val_type = USB_MIXER_U8;
1401 const unsigned int control = 5;
1402 const unsigned int cmask = 0;
1403
1404 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1405 name, NULL);
1406}
1407
1408static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1409{
1410 char name[64];
1411 unsigned int cmask;
1412 int chan, err;
1413 int num_outs = 0;
1414 int num_ins = 0;
1415
1416 const unsigned int id = 0x42;
1417 const int val_type = USB_MIXER_S16;
1418 const int control = 1;
1419
1420 switch (mixer->chip->usb_id) {
1421 case USB_ID(0x0763, 0x2030):
1422 num_outs = 6;
1423 num_ins = 4;
1424 break;
1425 case USB_ID(0x0763, 0x2031):
1426 num_outs = 8;
1427 num_ins = 6;
1428 break;
1429 }
1430
1431 for (chan = 0; chan < num_outs + num_ins; chan++) {
1432 if (chan < num_outs) {
1433 snprintf(name, sizeof(name),
1434 "Effect Send DOut%d",
1435 chan + 1);
1436 } else {
1437 snprintf(name, sizeof(name),
1438 "Effect Send AIn%d",
1439 chan - num_outs + 1);
1440 }
1441
1442 cmask = (chan == 0) ? 0 : BIT(chan - 1);
1443 err = snd_create_std_mono_ctl(mixer, id, control,
1444 cmask, val_type, name,
1445 &snd_usb_mixer_vol_tlv);
1446 if (err < 0)
1447 return err;
1448 }
1449
1450 return 0;
1451}
1452
1453static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1454{
1455 char name[64];
1456 unsigned int cmask;
1457 int chan, err;
1458 int num_outs = 0;
1459 int offset = 0;
1460
1461 const unsigned int id = 0x40;
1462 const int val_type = USB_MIXER_S16;
1463 const int control = 1;
1464
1465 switch (mixer->chip->usb_id) {
1466 case USB_ID(0x0763, 0x2030):
1467 num_outs = 6;
1468 offset = 0x3c;
1469 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1470 break;
1471 case USB_ID(0x0763, 0x2031):
1472 num_outs = 8;
1473 offset = 0x70;
1474 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1475 break;
1476 }
1477
1478 for (chan = 0; chan < num_outs; chan++) {
1479 snprintf(name, sizeof(name),
1480 "Effect Return %d",
1481 chan + 1);
1482
1483 cmask = (chan == 0) ? 0 :
1484 BIT(chan + (chan % 2) * num_outs - 1);
1485 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1486 cmask, val_type, offset, name,
1487 &snd_usb_mixer_vol_tlv);
1488 if (err < 0)
1489 return err;
1490 }
1491
1492 return 0;
1493}
1494
1495static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1496{
1497 int err;
1498
1499 err = snd_c400_create_vol_ctls(mixer);
1500 if (err < 0)
1501 return err;
1502
1503 err = snd_c400_create_effect_vol_ctls(mixer);
1504 if (err < 0)
1505 return err;
1506
1507 err = snd_c400_create_effect_ret_vol_ctls(mixer);
1508 if (err < 0)
1509 return err;
1510
1511 err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1512 if (err < 0)
1513 return err;
1514
1515 err = snd_c400_create_effect_volume_ctl(mixer);
1516 if (err < 0)
1517 return err;
1518
1519 err = snd_c400_create_effect_duration_ctl(mixer);
1520 if (err < 0)
1521 return err;
1522
1523 err = snd_c400_create_effect_feedback_ctl(mixer);
1524 if (err < 0)
1525 return err;
1526
1527 return 0;
1528}
1529
1530/*
1531 * The mixer units for Ebox-44 are corrupt, and even where they
1532 * are valid they presents mono controls as L and R channels of
1533 * stereo. So we provide a good mixer here.
1534 */
1535static const struct std_mono_table ebox44_table[] = {
1536 {
1537 .unitid = 4,
1538 .control = 1,
1539 .cmask = 0x0,
1540 .val_type = USB_MIXER_INV_BOOLEAN,
1541 .name = "Headphone Playback Switch"
1542 },
1543 {
1544 .unitid = 4,
1545 .control = 2,
1546 .cmask = 0x1,
1547 .val_type = USB_MIXER_S16,
1548 .name = "Headphone A Mix Playback Volume"
1549 },
1550 {
1551 .unitid = 4,
1552 .control = 2,
1553 .cmask = 0x2,
1554 .val_type = USB_MIXER_S16,
1555 .name = "Headphone B Mix Playback Volume"
1556 },
1557
1558 {
1559 .unitid = 7,
1560 .control = 1,
1561 .cmask = 0x0,
1562 .val_type = USB_MIXER_INV_BOOLEAN,
1563 .name = "Output Playback Switch"
1564 },
1565 {
1566 .unitid = 7,
1567 .control = 2,
1568 .cmask = 0x1,
1569 .val_type = USB_MIXER_S16,
1570 .name = "Output A Playback Volume"
1571 },
1572 {
1573 .unitid = 7,
1574 .control = 2,
1575 .cmask = 0x2,
1576 .val_type = USB_MIXER_S16,
1577 .name = "Output B Playback Volume"
1578 },
1579
1580 {
1581 .unitid = 10,
1582 .control = 1,
1583 .cmask = 0x0,
1584 .val_type = USB_MIXER_INV_BOOLEAN,
1585 .name = "Input Capture Switch"
1586 },
1587 {
1588 .unitid = 10,
1589 .control = 2,
1590 .cmask = 0x1,
1591 .val_type = USB_MIXER_S16,
1592 .name = "Input A Capture Volume"
1593 },
1594 {
1595 .unitid = 10,
1596 .control = 2,
1597 .cmask = 0x2,
1598 .val_type = USB_MIXER_S16,
1599 .name = "Input B Capture Volume"
1600 },
1601
1602 {}
1603};
1604
1605/* Audio Advantage Micro II findings:
1606 *
1607 * Mapping spdif AES bits to vendor register.bit:
1608 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1609 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1610 * AES2: [0 0 0 0 0 0 0 0]
1611 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1612 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1613 *
1614 * power on values:
1615 * r2: 0x10
1616 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1617 * just after it to 0xa0, presumably it disables/mutes some analog
1618 * parts when there is no audio.)
1619 * r9: 0x28
1620 *
1621 * Optical transmitter on/off:
1622 * vendor register.bit: 9.1
1623 * 0 - on (0x28 register value)
1624 * 1 - off (0x2a register value)
1625 *
1626 */
1627static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1628 struct snd_ctl_elem_info *uinfo)
1629{
1630 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1631 uinfo->count = 1;
1632 return 0;
1633}
1634
1635static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1636 struct snd_ctl_elem_value *ucontrol)
1637{
1638 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1639 struct snd_usb_audio *chip = list->mixer->chip;
1640 int err;
1641 struct usb_interface *iface;
1642 struct usb_host_interface *alts;
1643 unsigned int ep;
1644 unsigned char data[3];
1645 int rate;
1646
1647 err = snd_usb_lock_shutdown(chip);
1648 if (err < 0)
1649 return err;
1650
1651 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1652 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1653 ucontrol->value.iec958.status[2] = 0x00;
1654
1655 /* use known values for that card: interface#1 altsetting#1 */
1656 iface = usb_ifnum_to_if(chip->dev, 1);
1657 if (!iface || iface->num_altsetting < 2) {
1658 err = -EINVAL;
1659 goto end;
1660 }
1661 alts = &iface->altsetting[1];
1662 if (get_iface_desc(alts)->bNumEndpoints < 1) {
1663 err = -EINVAL;
1664 goto end;
1665 }
1666 ep = get_endpoint(alts, 0)->bEndpointAddress;
1667
1668 err = snd_usb_ctl_msg(chip->dev,
1669 usb_rcvctrlpipe(chip->dev, 0),
1670 UAC_GET_CUR,
1671 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1672 UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1673 ep,
1674 data,
1675 sizeof(data));
1676 if (err < 0)
1677 goto end;
1678
1679 rate = data[0] | (data[1] << 8) | (data[2] << 16);
1680 ucontrol->value.iec958.status[3] = (rate == 48000) ?
1681 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1682
1683 err = 0;
1684 end:
1685 snd_usb_unlock_shutdown(chip);
1686 return err;
1687}
1688
1689static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list)
1690{
1691 struct snd_usb_audio *chip = list->mixer->chip;
1692 unsigned int pval = list->kctl->private_value;
1693 u8 reg;
1694 int err;
1695
1696 err = snd_usb_lock_shutdown(chip);
1697 if (err < 0)
1698 return err;
1699
1700 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f);
1701 err = snd_usb_ctl_msg(chip->dev,
1702 usb_sndctrlpipe(chip->dev, 0),
1703 UAC_SET_CUR,
1704 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1705 reg,
1706 2,
1707 NULL,
1708 0);
1709 if (err < 0)
1710 goto end;
1711
1712 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20;
1713 reg |= (pval >> 12) & 0x0f;
1714 err = snd_usb_ctl_msg(chip->dev,
1715 usb_sndctrlpipe(chip->dev, 0),
1716 UAC_SET_CUR,
1717 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1718 reg,
1719 3,
1720 NULL,
1721 0);
1722 if (err < 0)
1723 goto end;
1724
1725 end:
1726 snd_usb_unlock_shutdown(chip);
1727 return err;
1728}
1729
1730static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1731 struct snd_ctl_elem_value *ucontrol)
1732{
1733 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1734 unsigned int pval, pval_old;
1735 int err;
1736
1737 pval = pval_old = kcontrol->private_value;
1738 pval &= 0xfffff0f0;
1739 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1740 pval |= (ucontrol->value.iec958.status[0] & 0x0f);
1741
1742 pval &= 0xffff0fff;
1743 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1744
1745 /* The frequency bits in AES3 cannot be set via register access. */
1746
1747 /* Silently ignore any bits from the request that cannot be set. */
1748
1749 if (pval == pval_old)
1750 return 0;
1751
1752 kcontrol->private_value = pval;
1753 err = snd_microii_spdif_default_update(list);
1754 return err < 0 ? err : 1;
1755}
1756
1757static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1758 struct snd_ctl_elem_value *ucontrol)
1759{
1760 ucontrol->value.iec958.status[0] = 0x0f;
1761 ucontrol->value.iec958.status[1] = 0xff;
1762 ucontrol->value.iec958.status[2] = 0x00;
1763 ucontrol->value.iec958.status[3] = 0x00;
1764
1765 return 0;
1766}
1767
1768static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1769 struct snd_ctl_elem_value *ucontrol)
1770{
1771 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1772
1773 return 0;
1774}
1775
1776static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list)
1777{
1778 struct snd_usb_audio *chip = list->mixer->chip;
1779 u8 reg = list->kctl->private_value;
1780 int err;
1781
1782 err = snd_usb_lock_shutdown(chip);
1783 if (err < 0)
1784 return err;
1785
1786 err = snd_usb_ctl_msg(chip->dev,
1787 usb_sndctrlpipe(chip->dev, 0),
1788 UAC_SET_CUR,
1789 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1790 reg,
1791 9,
1792 NULL,
1793 0);
1794
1795 snd_usb_unlock_shutdown(chip);
1796 return err;
1797}
1798
1799static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1800 struct snd_ctl_elem_value *ucontrol)
1801{
1802 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1803 u8 reg;
1804 int err;
1805
1806 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1807 if (reg != list->kctl->private_value)
1808 return 0;
1809
1810 kcontrol->private_value = reg;
1811 err = snd_microii_spdif_switch_update(list);
1812 return err < 0 ? err : 1;
1813}
1814
1815static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1816 {
1817 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1818 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1819 .info = snd_microii_spdif_info,
1820 .get = snd_microii_spdif_default_get,
1821 .put = snd_microii_spdif_default_put,
1822 .private_value = 0x00000100UL,/* reset value */
1823 },
1824 {
1825 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1826 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1827 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1828 .info = snd_microii_spdif_info,
1829 .get = snd_microii_spdif_mask_get,
1830 },
1831 {
1832 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1833 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1834 .info = snd_ctl_boolean_mono_info,
1835 .get = snd_microii_spdif_switch_get,
1836 .put = snd_microii_spdif_switch_put,
1837 .private_value = 0x00000028UL,/* reset value */
1838 }
1839};
1840
1841static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1842{
1843 int err, i;
1844 static const usb_mixer_elem_resume_func_t resume_funcs[] = {
1845 snd_microii_spdif_default_update,
1846 NULL,
1847 snd_microii_spdif_switch_update
1848 };
1849
1850 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1851 err = add_single_ctl_with_resume(mixer, 0,
1852 resume_funcs[i],
1853 &snd_microii_mixer_spdif[i],
1854 NULL);
1855 if (err < 0)
1856 return err;
1857 }
1858
1859 return 0;
1860}
1861
1862/* Creative Sound Blaster E1 */
1863
1864static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol,
1865 struct snd_ctl_elem_value *ucontrol)
1866{
1867 ucontrol->value.integer.value[0] = kcontrol->private_value;
1868 return 0;
1869}
1870
1871static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer,
1872 unsigned char state)
1873{
1874 struct snd_usb_audio *chip = mixer->chip;
1875 int err;
1876 unsigned char buff[2];
1877
1878 buff[0] = 0x02;
1879 buff[1] = state ? 0x02 : 0x00;
1880
1881 err = snd_usb_lock_shutdown(chip);
1882 if (err < 0)
1883 return err;
1884 err = snd_usb_ctl_msg(chip->dev,
1885 usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT,
1886 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
1887 0x0202, 3, buff, 2);
1888 snd_usb_unlock_shutdown(chip);
1889 return err;
1890}
1891
1892static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol,
1893 struct snd_ctl_elem_value *ucontrol)
1894{
1895 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1896 unsigned char value = !!ucontrol->value.integer.value[0];
1897 int err;
1898
1899 if (kcontrol->private_value == value)
1900 return 0;
1901 kcontrol->private_value = value;
1902 err = snd_soundblaster_e1_switch_update(list->mixer, value);
1903 return err < 0 ? err : 1;
1904}
1905
1906static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list)
1907{
1908 return snd_soundblaster_e1_switch_update(list->mixer,
1909 list->kctl->private_value);
1910}
1911
1912static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol,
1913 struct snd_ctl_elem_info *uinfo)
1914{
1915 static const char *const texts[2] = {
1916 "Mic", "Aux"
1917 };
1918
1919 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1920}
1921
1922static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = {
1923 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1924 .name = "Input Source",
1925 .info = snd_soundblaster_e1_switch_info,
1926 .get = snd_soundblaster_e1_switch_get,
1927 .put = snd_soundblaster_e1_switch_put,
1928 .private_value = 0,
1929};
1930
1931static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer)
1932{
1933 return add_single_ctl_with_resume(mixer, 0,
1934 snd_soundblaster_e1_switch_resume,
1935 &snd_soundblaster_e1_input_switch,
1936 NULL);
1937}
1938
1939/*
1940 * Dell WD15 dock jack detection
1941 *
1942 * The WD15 contains an ALC4020 USB audio controller and ALC3263 audio codec
1943 * from Realtek. It is a UAC 1 device, and UAC 1 does not support jack
1944 * detection. Instead, jack detection works by sending HD Audio commands over
1945 * vendor-type USB messages.
1946 */
1947
1948#define HDA_VERB_CMD(V, N, D) (((N) << 20) | ((V) << 8) | (D))
1949
1950#define REALTEK_HDA_VALUE 0x0038
1951
1952#define REALTEK_HDA_SET 62
1953#define REALTEK_MANUAL_MODE 72
1954#define REALTEK_HDA_GET_OUT 88
1955#define REALTEK_HDA_GET_IN 89
1956
1957#define REALTEK_AUDIO_FUNCTION_GROUP 0x01
1958#define REALTEK_LINE1 0x1a
1959#define REALTEK_VENDOR_REGISTERS 0x20
1960#define REALTEK_HP_OUT 0x21
1961
1962#define REALTEK_CBJ_CTRL2 0x50
1963
1964#define REALTEK_JACK_INTERRUPT_NODE 5
1965
1966#define REALTEK_MIC_FLAG 0x100
1967
1968static int realtek_hda_set(struct snd_usb_audio *chip, u32 cmd)
1969{
1970 struct usb_device *dev = chip->dev;
1971 __be32 buf = cpu_to_be32(cmd);
1972
1973 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_HDA_SET,
1974 USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT,
1975 REALTEK_HDA_VALUE, 0, &buf, sizeof(buf));
1976}
1977
1978static int realtek_hda_get(struct snd_usb_audio *chip, u32 cmd, u32 *value)
1979{
1980 struct usb_device *dev = chip->dev;
1981 int err;
1982 __be32 buf = cpu_to_be32(cmd);
1983
1984 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_HDA_GET_OUT,
1985 USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT,
1986 REALTEK_HDA_VALUE, 0, &buf, sizeof(buf));
1987 if (err < 0)
1988 return err;
1989 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), REALTEK_HDA_GET_IN,
1990 USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_IN,
1991 REALTEK_HDA_VALUE, 0, &buf, sizeof(buf));
1992 if (err < 0)
1993 return err;
1994
1995 *value = be32_to_cpu(buf);
1996 return 0;
1997}
1998
1999static int realtek_ctl_connector_get(struct snd_kcontrol *kcontrol,
2000 struct snd_ctl_elem_value *ucontrol)
2001{
2002 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2003 struct snd_usb_audio *chip = cval->head.mixer->chip;
2004 u32 pv = kcontrol->private_value;
2005 u32 node_id = pv & 0xff;
2006 u32 sense;
2007 u32 cbj_ctrl2;
2008 bool presence;
2009 int err;
2010
2011 err = snd_usb_lock_shutdown(chip);
2012 if (err < 0)
2013 return err;
2014 err = realtek_hda_get(chip,
2015 HDA_VERB_CMD(AC_VERB_GET_PIN_SENSE, node_id, 0),
2016 &sense);
2017 if (err < 0)
2018 goto err;
2019 if (pv & REALTEK_MIC_FLAG) {
2020 err = realtek_hda_set(chip,
2021 HDA_VERB_CMD(AC_VERB_SET_COEF_INDEX,
2022 REALTEK_VENDOR_REGISTERS,
2023 REALTEK_CBJ_CTRL2));
2024 if (err < 0)
2025 goto err;
2026 err = realtek_hda_get(chip,
2027 HDA_VERB_CMD(AC_VERB_GET_PROC_COEF,
2028 REALTEK_VENDOR_REGISTERS, 0),
2029 &cbj_ctrl2);
2030 if (err < 0)
2031 goto err;
2032 }
2033err:
2034 snd_usb_unlock_shutdown(chip);
2035 if (err < 0)
2036 return err;
2037
2038 presence = sense & AC_PINSENSE_PRESENCE;
2039 if (pv & REALTEK_MIC_FLAG)
2040 presence = presence && (cbj_ctrl2 & 0x0070) == 0x0070;
2041 ucontrol->value.integer.value[0] = presence;
2042 return 0;
2043}
2044
2045static const struct snd_kcontrol_new realtek_connector_ctl_ro = {
2046 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
2047 .name = "", /* will be filled later manually */
2048 .access = SNDRV_CTL_ELEM_ACCESS_READ,
2049 .info = snd_ctl_boolean_mono_info,
2050 .get = realtek_ctl_connector_get,
2051};
2052
2053static int realtek_resume_jack(struct usb_mixer_elem_list *list)
2054{
2055 snd_ctl_notify(list->mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
2056 &list->kctl->id);
2057 return 0;
2058}
2059
2060static int realtek_add_jack(struct usb_mixer_interface *mixer,
2061 char *name, u32 val)
2062{
2063 struct usb_mixer_elem_info *cval;
2064 struct snd_kcontrol *kctl;
2065
2066 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2067 if (!cval)
2068 return -ENOMEM;
2069 snd_usb_mixer_elem_init_std(&cval->head, mixer,
2070 REALTEK_JACK_INTERRUPT_NODE);
2071 cval->head.resume = realtek_resume_jack;
2072 cval->val_type = USB_MIXER_BOOLEAN;
2073 cval->channels = 1;
2074 cval->min = 0;
2075 cval->max = 1;
2076 kctl = snd_ctl_new1(&realtek_connector_ctl_ro, cval);
2077 if (!kctl) {
2078 kfree(cval);
2079 return -ENOMEM;
2080 }
2081 kctl->private_value = val;
2082 strscpy(kctl->id.name, name, sizeof(kctl->id.name));
2083 kctl->private_free = snd_usb_mixer_elem_free;
2084 return snd_usb_mixer_add_control(&cval->head, kctl);
2085}
2086
2087static int dell_dock_mixer_create(struct usb_mixer_interface *mixer)
2088{
2089 int err;
2090 struct usb_device *dev = mixer->chip->dev;
2091
2092 /* Power down the audio codec to avoid loud pops in the next step. */
2093 realtek_hda_set(mixer->chip,
2094 HDA_VERB_CMD(AC_VERB_SET_POWER_STATE,
2095 REALTEK_AUDIO_FUNCTION_GROUP,
2096 AC_PWRST_D3));
2097
2098 /*
2099 * Turn off 'manual mode' in case it was enabled. This removes the need
2100 * to power cycle the dock after it was attached to a Windows machine.
2101 */
2102 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_MANUAL_MODE,
2103 USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT,
2104 0, 0, NULL, 0);
2105
2106 err = realtek_add_jack(mixer, "Line Out Jack", REALTEK_LINE1);
2107 if (err < 0)
2108 return err;
2109 err = realtek_add_jack(mixer, "Headphone Jack", REALTEK_HP_OUT);
2110 if (err < 0)
2111 return err;
2112 err = realtek_add_jack(mixer, "Headset Mic Jack",
2113 REALTEK_HP_OUT | REALTEK_MIC_FLAG);
2114 if (err < 0)
2115 return err;
2116 return 0;
2117}
2118
2119static void dell_dock_init_vol(struct usb_mixer_interface *mixer, int ch, int id)
2120{
2121 struct snd_usb_audio *chip = mixer->chip;
2122 u16 buf = 0;
2123
2124 snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
2125 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
2126 (UAC_FU_VOLUME << 8) | ch,
2127 snd_usb_ctrl_intf(mixer->hostif) | (id << 8),
2128 &buf, 2);
2129}
2130
2131static int dell_dock_mixer_init(struct usb_mixer_interface *mixer)
2132{
2133 /* fix to 0dB playback volumes */
2134 dell_dock_init_vol(mixer, 1, 16);
2135 dell_dock_init_vol(mixer, 2, 16);
2136 dell_dock_init_vol(mixer, 1, 19);
2137 dell_dock_init_vol(mixer, 2, 19);
2138 return 0;
2139}
2140
2141/* RME Class Compliant device quirks */
2142
2143#define SND_RME_GET_STATUS1 23
2144#define SND_RME_GET_CURRENT_FREQ 17
2145#define SND_RME_CLK_SYSTEM_SHIFT 16
2146#define SND_RME_CLK_SYSTEM_MASK 0x1f
2147#define SND_RME_CLK_AES_SHIFT 8
2148#define SND_RME_CLK_SPDIF_SHIFT 12
2149#define SND_RME_CLK_AES_SPDIF_MASK 0xf
2150#define SND_RME_CLK_SYNC_SHIFT 6
2151#define SND_RME_CLK_SYNC_MASK 0x3
2152#define SND_RME_CLK_FREQMUL_SHIFT 18
2153#define SND_RME_CLK_FREQMUL_MASK 0x7
2154#define SND_RME_CLK_SYSTEM(x) \
2155 ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK)
2156#define SND_RME_CLK_AES(x) \
2157 ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
2158#define SND_RME_CLK_SPDIF(x) \
2159 ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
2160#define SND_RME_CLK_SYNC(x) \
2161 ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK)
2162#define SND_RME_CLK_FREQMUL(x) \
2163 ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK)
2164#define SND_RME_CLK_AES_LOCK 0x1
2165#define SND_RME_CLK_AES_SYNC 0x4
2166#define SND_RME_CLK_SPDIF_LOCK 0x2
2167#define SND_RME_CLK_SPDIF_SYNC 0x8
2168#define SND_RME_SPDIF_IF_SHIFT 4
2169#define SND_RME_SPDIF_FORMAT_SHIFT 5
2170#define SND_RME_BINARY_MASK 0x1
2171#define SND_RME_SPDIF_IF(x) \
2172 ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK)
2173#define SND_RME_SPDIF_FORMAT(x) \
2174 ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK)
2175
2176static const u32 snd_rme_rate_table[] = {
2177 32000, 44100, 48000, 50000,
2178 64000, 88200, 96000, 100000,
2179 128000, 176400, 192000, 200000,
2180 256000, 352800, 384000, 400000,
2181 512000, 705600, 768000, 800000
2182};
2183/* maximum number of items for AES and S/PDIF rates for above table */
2184#define SND_RME_RATE_IDX_AES_SPDIF_NUM 12
2185
2186enum snd_rme_domain {
2187 SND_RME_DOMAIN_SYSTEM,
2188 SND_RME_DOMAIN_AES,
2189 SND_RME_DOMAIN_SPDIF
2190};
2191
2192enum snd_rme_clock_status {
2193 SND_RME_CLOCK_NOLOCK,
2194 SND_RME_CLOCK_LOCK,
2195 SND_RME_CLOCK_SYNC
2196};
2197
2198static int snd_rme_read_value(struct snd_usb_audio *chip,
2199 unsigned int item,
2200 u32 *value)
2201{
2202 struct usb_device *dev = chip->dev;
2203 int err;
2204
2205 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
2206 item,
2207 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2208 0, 0,
2209 value, sizeof(*value));
2210 if (err < 0)
2211 dev_err(&dev->dev,
2212 "unable to issue vendor read request %d (ret = %d)",
2213 item, err);
2214 return err;
2215}
2216
2217static int snd_rme_get_status1(struct snd_kcontrol *kcontrol,
2218 u32 *status1)
2219{
2220 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2221 struct snd_usb_audio *chip = list->mixer->chip;
2222 int err;
2223
2224 err = snd_usb_lock_shutdown(chip);
2225 if (err < 0)
2226 return err;
2227 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1);
2228 snd_usb_unlock_shutdown(chip);
2229 return err;
2230}
2231
2232static int snd_rme_rate_get(struct snd_kcontrol *kcontrol,
2233 struct snd_ctl_elem_value *ucontrol)
2234{
2235 u32 status1;
2236 u32 rate = 0;
2237 int idx;
2238 int err;
2239
2240 err = snd_rme_get_status1(kcontrol, &status1);
2241 if (err < 0)
2242 return err;
2243 switch (kcontrol->private_value) {
2244 case SND_RME_DOMAIN_SYSTEM:
2245 idx = SND_RME_CLK_SYSTEM(status1);
2246 if (idx < ARRAY_SIZE(snd_rme_rate_table))
2247 rate = snd_rme_rate_table[idx];
2248 break;
2249 case SND_RME_DOMAIN_AES:
2250 idx = SND_RME_CLK_AES(status1);
2251 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
2252 rate = snd_rme_rate_table[idx];
2253 break;
2254 case SND_RME_DOMAIN_SPDIF:
2255 idx = SND_RME_CLK_SPDIF(status1);
2256 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
2257 rate = snd_rme_rate_table[idx];
2258 break;
2259 default:
2260 return -EINVAL;
2261 }
2262 ucontrol->value.integer.value[0] = rate;
2263 return 0;
2264}
2265
2266static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol,
2267 struct snd_ctl_elem_value *ucontrol)
2268{
2269 u32 status1;
2270 int idx = SND_RME_CLOCK_NOLOCK;
2271 int err;
2272
2273 err = snd_rme_get_status1(kcontrol, &status1);
2274 if (err < 0)
2275 return err;
2276 switch (kcontrol->private_value) {
2277 case SND_RME_DOMAIN_AES: /* AES */
2278 if (status1 & SND_RME_CLK_AES_SYNC)
2279 idx = SND_RME_CLOCK_SYNC;
2280 else if (status1 & SND_RME_CLK_AES_LOCK)
2281 idx = SND_RME_CLOCK_LOCK;
2282 break;
2283 case SND_RME_DOMAIN_SPDIF: /* SPDIF */
2284 if (status1 & SND_RME_CLK_SPDIF_SYNC)
2285 idx = SND_RME_CLOCK_SYNC;
2286 else if (status1 & SND_RME_CLK_SPDIF_LOCK)
2287 idx = SND_RME_CLOCK_LOCK;
2288 break;
2289 default:
2290 return -EINVAL;
2291 }
2292 ucontrol->value.enumerated.item[0] = idx;
2293 return 0;
2294}
2295
2296static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol,
2297 struct snd_ctl_elem_value *ucontrol)
2298{
2299 u32 status1;
2300 int err;
2301
2302 err = snd_rme_get_status1(kcontrol, &status1);
2303 if (err < 0)
2304 return err;
2305 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1);
2306 return 0;
2307}
2308
2309static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol,
2310 struct snd_ctl_elem_value *ucontrol)
2311{
2312 u32 status1;
2313 int err;
2314
2315 err = snd_rme_get_status1(kcontrol, &status1);
2316 if (err < 0)
2317 return err;
2318 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1);
2319 return 0;
2320}
2321
2322static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol,
2323 struct snd_ctl_elem_value *ucontrol)
2324{
2325 u32 status1;
2326 int err;
2327
2328 err = snd_rme_get_status1(kcontrol, &status1);
2329 if (err < 0)
2330 return err;
2331 ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1);
2332 return 0;
2333}
2334
2335static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol,
2336 struct snd_ctl_elem_value *ucontrol)
2337{
2338 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2339 struct snd_usb_audio *chip = list->mixer->chip;
2340 u32 status1;
2341 const u64 num = 104857600000000ULL;
2342 u32 den;
2343 unsigned int freq;
2344 int err;
2345
2346 err = snd_usb_lock_shutdown(chip);
2347 if (err < 0)
2348 return err;
2349 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1);
2350 if (err < 0)
2351 goto end;
2352 err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den);
2353 if (err < 0)
2354 goto end;
2355 freq = (den == 0) ? 0 : div64_u64(num, den);
2356 freq <<= SND_RME_CLK_FREQMUL(status1);
2357 ucontrol->value.integer.value[0] = freq;
2358
2359end:
2360 snd_usb_unlock_shutdown(chip);
2361 return err;
2362}
2363
2364static int snd_rme_rate_info(struct snd_kcontrol *kcontrol,
2365 struct snd_ctl_elem_info *uinfo)
2366{
2367 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2368 uinfo->count = 1;
2369 switch (kcontrol->private_value) {
2370 case SND_RME_DOMAIN_SYSTEM:
2371 uinfo->value.integer.min = 32000;
2372 uinfo->value.integer.max = 800000;
2373 break;
2374 case SND_RME_DOMAIN_AES:
2375 case SND_RME_DOMAIN_SPDIF:
2376 default:
2377 uinfo->value.integer.min = 0;
2378 uinfo->value.integer.max = 200000;
2379 }
2380 uinfo->value.integer.step = 0;
2381 return 0;
2382}
2383
2384static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol,
2385 struct snd_ctl_elem_info *uinfo)
2386{
2387 static const char *const sync_states[] = {
2388 "No Lock", "Lock", "Sync"
2389 };
2390
2391 return snd_ctl_enum_info(uinfo, 1,
2392 ARRAY_SIZE(sync_states), sync_states);
2393}
2394
2395static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol,
2396 struct snd_ctl_elem_info *uinfo)
2397{
2398 static const char *const spdif_if[] = {
2399 "Coaxial", "Optical"
2400 };
2401
2402 return snd_ctl_enum_info(uinfo, 1,
2403 ARRAY_SIZE(spdif_if), spdif_if);
2404}
2405
2406static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol,
2407 struct snd_ctl_elem_info *uinfo)
2408{
2409 static const char *const optical_type[] = {
2410 "Consumer", "Professional"
2411 };
2412
2413 return snd_ctl_enum_info(uinfo, 1,
2414 ARRAY_SIZE(optical_type), optical_type);
2415}
2416
2417static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol,
2418 struct snd_ctl_elem_info *uinfo)
2419{
2420 static const char *const sync_sources[] = {
2421 "Internal", "AES", "SPDIF", "Internal"
2422 };
2423
2424 return snd_ctl_enum_info(uinfo, 1,
2425 ARRAY_SIZE(sync_sources), sync_sources);
2426}
2427
2428static const struct snd_kcontrol_new snd_rme_controls[] = {
2429 {
2430 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2431 .name = "AES Rate",
2432 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2433 .info = snd_rme_rate_info,
2434 .get = snd_rme_rate_get,
2435 .private_value = SND_RME_DOMAIN_AES
2436 },
2437 {
2438 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2439 .name = "AES Sync",
2440 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2441 .info = snd_rme_sync_state_info,
2442 .get = snd_rme_sync_state_get,
2443 .private_value = SND_RME_DOMAIN_AES
2444 },
2445 {
2446 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2447 .name = "SPDIF Rate",
2448 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2449 .info = snd_rme_rate_info,
2450 .get = snd_rme_rate_get,
2451 .private_value = SND_RME_DOMAIN_SPDIF
2452 },
2453 {
2454 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2455 .name = "SPDIF Sync",
2456 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2457 .info = snd_rme_sync_state_info,
2458 .get = snd_rme_sync_state_get,
2459 .private_value = SND_RME_DOMAIN_SPDIF
2460 },
2461 {
2462 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2463 .name = "SPDIF Interface",
2464 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2465 .info = snd_rme_spdif_if_info,
2466 .get = snd_rme_spdif_if_get,
2467 },
2468 {
2469 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2470 .name = "SPDIF Format",
2471 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2472 .info = snd_rme_spdif_format_info,
2473 .get = snd_rme_spdif_format_get,
2474 },
2475 {
2476 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2477 .name = "Sync Source",
2478 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2479 .info = snd_rme_sync_source_info,
2480 .get = snd_rme_sync_source_get
2481 },
2482 {
2483 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2484 .name = "System Rate",
2485 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2486 .info = snd_rme_rate_info,
2487 .get = snd_rme_rate_get,
2488 .private_value = SND_RME_DOMAIN_SYSTEM
2489 },
2490 {
2491 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2492 .name = "Current Frequency",
2493 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2494 .info = snd_rme_rate_info,
2495 .get = snd_rme_current_freq_get
2496 }
2497};
2498
2499static int snd_rme_controls_create(struct usb_mixer_interface *mixer)
2500{
2501 int err, i;
2502
2503 for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) {
2504 err = add_single_ctl_with_resume(mixer, 0,
2505 NULL,
2506 &snd_rme_controls[i],
2507 NULL);
2508 if (err < 0)
2509 return err;
2510 }
2511
2512 return 0;
2513}
2514
2515/*
2516 * RME Babyface Pro (FS)
2517 *
2518 * These devices exposes a couple of DSP functions via request to EP0.
2519 * Switches are available via control registers, while routing is controlled
2520 * by controlling the volume on each possible crossing point.
2521 * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with
2522 * 0dB being at dec. 32768.
2523 */
2524enum {
2525 SND_BBFPRO_CTL_REG1 = 0,
2526 SND_BBFPRO_CTL_REG2
2527};
2528
2529#define SND_BBFPRO_CTL_REG_MASK 1
2530#define SND_BBFPRO_CTL_IDX_MASK 0xff
2531#define SND_BBFPRO_CTL_IDX_SHIFT 1
2532#define SND_BBFPRO_CTL_VAL_MASK 1
2533#define SND_BBFPRO_CTL_VAL_SHIFT 9
2534#define SND_BBFPRO_CTL_REG1_CLK_MASTER 0
2535#define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1
2536#define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7
2537#define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8
2538#define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10
2539#define SND_BBFPRO_CTL_REG2_48V_AN1 0
2540#define SND_BBFPRO_CTL_REG2_48V_AN2 1
2541#define SND_BBFPRO_CTL_REG2_SENS_IN3 2
2542#define SND_BBFPRO_CTL_REG2_SENS_IN4 3
2543#define SND_BBFPRO_CTL_REG2_PAD_AN1 4
2544#define SND_BBFPRO_CTL_REG2_PAD_AN2 5
2545
2546#define SND_BBFPRO_MIXER_MAIN_OUT_CH_OFFSET 992
2547#define SND_BBFPRO_MIXER_IDX_MASK 0x3ff
2548#define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff
2549#define SND_BBFPRO_MIXER_VAL_SHIFT 9
2550#define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf
2551#define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB
2552
2553#define SND_BBFPRO_GAIN_CHANNEL_MASK 0x03
2554#define SND_BBFPRO_GAIN_CHANNEL_SHIFT 7
2555#define SND_BBFPRO_GAIN_VAL_MASK 0x7f
2556#define SND_BBFPRO_GAIN_VAL_MIN 0
2557#define SND_BBFPRO_GAIN_VAL_MIC_MAX 65
2558#define SND_BBFPRO_GAIN_VAL_LINE_MAX 18 // 9db in 0.5db incraments
2559
2560#define SND_BBFPRO_USBREQ_CTL_REG1 0x10
2561#define SND_BBFPRO_USBREQ_CTL_REG2 0x17
2562#define SND_BBFPRO_USBREQ_GAIN 0x1a
2563#define SND_BBFPRO_USBREQ_MIXER 0x12
2564
2565static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg,
2566 u8 index, u8 value)
2567{
2568 int err;
2569 u16 usb_req, usb_idx, usb_val;
2570 struct snd_usb_audio *chip = mixer->chip;
2571
2572 err = snd_usb_lock_shutdown(chip);
2573 if (err < 0)
2574 return err;
2575
2576 if (reg == SND_BBFPRO_CTL_REG1) {
2577 usb_req = SND_BBFPRO_USBREQ_CTL_REG1;
2578 if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2579 usb_idx = 3;
2580 usb_val = value ? 3 : 0;
2581 } else {
2582 usb_idx = BIT(index);
2583 usb_val = value ? usb_idx : 0;
2584 }
2585 } else {
2586 usb_req = SND_BBFPRO_USBREQ_CTL_REG2;
2587 usb_idx = BIT(index);
2588 usb_val = value ? usb_idx : 0;
2589 }
2590
2591 err = snd_usb_ctl_msg(chip->dev,
2592 usb_sndctrlpipe(chip->dev, 0), usb_req,
2593 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2594 usb_val, usb_idx, NULL, 0);
2595
2596 snd_usb_unlock_shutdown(chip);
2597 return err;
2598}
2599
2600static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol,
2601 struct snd_ctl_elem_value *ucontrol)
2602{
2603 u8 reg, idx, val;
2604 int pv;
2605
2606 pv = kcontrol->private_value;
2607 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2608 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2609 val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT;
2610
2611 if ((reg == SND_BBFPRO_CTL_REG1 &&
2612 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2613 (reg == SND_BBFPRO_CTL_REG2 &&
2614 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2615 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2616 ucontrol->value.enumerated.item[0] = val;
2617 } else {
2618 ucontrol->value.integer.value[0] = val;
2619 }
2620 return 0;
2621}
2622
2623static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol,
2624 struct snd_ctl_elem_info *uinfo)
2625{
2626 u8 reg, idx;
2627 int pv;
2628
2629 pv = kcontrol->private_value;
2630 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2631 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2632
2633 if (reg == SND_BBFPRO_CTL_REG1 &&
2634 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2635 static const char * const texts[2] = {
2636 "AutoSync",
2637 "Internal"
2638 };
2639 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2640 } else if (reg == SND_BBFPRO_CTL_REG2 &&
2641 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2642 idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) {
2643 static const char * const texts[2] = {
2644 "-10dBV",
2645 "+4dBu"
2646 };
2647 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2648 }
2649
2650 uinfo->count = 1;
2651 uinfo->value.integer.min = 0;
2652 uinfo->value.integer.max = 1;
2653 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2654 return 0;
2655}
2656
2657static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol,
2658 struct snd_ctl_elem_value *ucontrol)
2659{
2660 int err;
2661 u8 reg, idx;
2662 int old_value, pv, val;
2663
2664 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2665 struct usb_mixer_interface *mixer = list->mixer;
2666
2667 pv = kcontrol->private_value;
2668 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2669 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2670 old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2671
2672 if ((reg == SND_BBFPRO_CTL_REG1 &&
2673 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2674 (reg == SND_BBFPRO_CTL_REG2 &&
2675 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2676 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2677 val = ucontrol->value.enumerated.item[0];
2678 } else {
2679 val = ucontrol->value.integer.value[0];
2680 }
2681
2682 if (val > 1)
2683 return -EINVAL;
2684
2685 if (val == old_value)
2686 return 0;
2687
2688 kcontrol->private_value = reg
2689 | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT)
2690 | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT);
2691
2692 err = snd_bbfpro_ctl_update(mixer, reg, idx, val);
2693 return err < 0 ? err : 1;
2694}
2695
2696static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list)
2697{
2698 u8 reg, idx;
2699 int value, pv;
2700
2701 pv = list->kctl->private_value;
2702 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2703 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2704 value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2705
2706 return snd_bbfpro_ctl_update(list->mixer, reg, idx, value);
2707}
2708
2709static int snd_bbfpro_gain_update(struct usb_mixer_interface *mixer,
2710 u8 channel, u8 gain)
2711{
2712 int err;
2713 struct snd_usb_audio *chip = mixer->chip;
2714
2715 if (channel < 2) {
2716 // XLR preamp: 3-bit fine, 5-bit coarse; special case >60
2717 if (gain < 60)
2718 gain = ((gain % 3) << 5) | (gain / 3);
2719 else
2720 gain = ((gain % 6) << 5) | (60 / 3);
2721 }
2722
2723 err = snd_usb_lock_shutdown(chip);
2724 if (err < 0)
2725 return err;
2726
2727 err = snd_usb_ctl_msg(chip->dev,
2728 usb_sndctrlpipe(chip->dev, 0),
2729 SND_BBFPRO_USBREQ_GAIN,
2730 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2731 gain, channel, NULL, 0);
2732
2733 snd_usb_unlock_shutdown(chip);
2734 return err;
2735}
2736
2737static int snd_bbfpro_gain_get(struct snd_kcontrol *kcontrol,
2738 struct snd_ctl_elem_value *ucontrol)
2739{
2740 int value = kcontrol->private_value & SND_BBFPRO_GAIN_VAL_MASK;
2741
2742 ucontrol->value.integer.value[0] = value;
2743 return 0;
2744}
2745
2746static int snd_bbfpro_gain_info(struct snd_kcontrol *kcontrol,
2747 struct snd_ctl_elem_info *uinfo)
2748{
2749 int pv, channel;
2750
2751 pv = kcontrol->private_value;
2752 channel = (pv >> SND_BBFPRO_GAIN_CHANNEL_SHIFT) &
2753 SND_BBFPRO_GAIN_CHANNEL_MASK;
2754
2755 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2756 uinfo->count = 1;
2757 uinfo->value.integer.min = SND_BBFPRO_GAIN_VAL_MIN;
2758
2759 if (channel < 2)
2760 uinfo->value.integer.max = SND_BBFPRO_GAIN_VAL_MIC_MAX;
2761 else
2762 uinfo->value.integer.max = SND_BBFPRO_GAIN_VAL_LINE_MAX;
2763
2764 return 0;
2765}
2766
2767static int snd_bbfpro_gain_put(struct snd_kcontrol *kcontrol,
2768 struct snd_ctl_elem_value *ucontrol)
2769{
2770 int pv, channel, old_value, value, err;
2771
2772 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2773 struct usb_mixer_interface *mixer = list->mixer;
2774
2775 pv = kcontrol->private_value;
2776 channel = (pv >> SND_BBFPRO_GAIN_CHANNEL_SHIFT) &
2777 SND_BBFPRO_GAIN_CHANNEL_MASK;
2778 old_value = pv & SND_BBFPRO_GAIN_VAL_MASK;
2779 value = ucontrol->value.integer.value[0];
2780
2781 if (value < SND_BBFPRO_GAIN_VAL_MIN)
2782 return -EINVAL;
2783
2784 if (channel < 2) {
2785 if (value > SND_BBFPRO_GAIN_VAL_MIC_MAX)
2786 return -EINVAL;
2787 } else {
2788 if (value > SND_BBFPRO_GAIN_VAL_LINE_MAX)
2789 return -EINVAL;
2790 }
2791
2792 if (value == old_value)
2793 return 0;
2794
2795 err = snd_bbfpro_gain_update(mixer, channel, value);
2796 if (err < 0)
2797 return err;
2798
2799 kcontrol->private_value =
2800 (channel << SND_BBFPRO_GAIN_CHANNEL_SHIFT) | value;
2801 return 1;
2802}
2803
2804static int snd_bbfpro_gain_resume(struct usb_mixer_elem_list *list)
2805{
2806 int pv, channel, value;
2807 struct snd_kcontrol *kctl = list->kctl;
2808
2809 pv = kctl->private_value;
2810 channel = (pv >> SND_BBFPRO_GAIN_CHANNEL_SHIFT) &
2811 SND_BBFPRO_GAIN_CHANNEL_MASK;
2812 value = pv & SND_BBFPRO_GAIN_VAL_MASK;
2813
2814 return snd_bbfpro_gain_update(list->mixer, channel, value);
2815}
2816
2817static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index,
2818 u32 value)
2819{
2820 struct snd_usb_audio *chip = mixer->chip;
2821 int err;
2822 u16 idx;
2823 u16 usb_idx, usb_val;
2824 u32 v;
2825
2826 err = snd_usb_lock_shutdown(chip);
2827 if (err < 0)
2828 return err;
2829
2830 idx = index & SND_BBFPRO_MIXER_IDX_MASK;
2831 // 18 bit linear volume, split so 2 bits end up in index.
2832 v = value & SND_BBFPRO_MIXER_VAL_MASK;
2833 usb_idx = idx | (v & 0x3) << 14;
2834 usb_val = (v >> 2) & 0xffff;
2835
2836 err = snd_usb_ctl_msg(chip->dev,
2837 usb_sndctrlpipe(chip->dev, 0),
2838 SND_BBFPRO_USBREQ_MIXER,
2839 USB_DIR_OUT | USB_TYPE_VENDOR |
2840 USB_RECIP_DEVICE,
2841 usb_val, usb_idx, NULL, 0);
2842
2843 snd_usb_unlock_shutdown(chip);
2844 return err;
2845}
2846
2847static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol,
2848 struct snd_ctl_elem_value *ucontrol)
2849{
2850 ucontrol->value.integer.value[0] =
2851 kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2852 return 0;
2853}
2854
2855static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol,
2856 struct snd_ctl_elem_info *uinfo)
2857{
2858 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2859 uinfo->count = 1;
2860 uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN;
2861 uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX;
2862 return 0;
2863}
2864
2865static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol,
2866 struct snd_ctl_elem_value *ucontrol)
2867{
2868 int err;
2869 u16 idx;
2870 u32 new_val, old_value, uvalue;
2871 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2872 struct usb_mixer_interface *mixer = list->mixer;
2873
2874 uvalue = ucontrol->value.integer.value[0];
2875 idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK;
2876 old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2877
2878 if (uvalue > SND_BBFPRO_MIXER_VAL_MAX)
2879 return -EINVAL;
2880
2881 if (uvalue == old_value)
2882 return 0;
2883
2884 new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK;
2885
2886 kcontrol->private_value = idx
2887 | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT);
2888
2889 err = snd_bbfpro_vol_update(mixer, idx, new_val);
2890 return err < 0 ? err : 1;
2891}
2892
2893static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list)
2894{
2895 int pv = list->kctl->private_value;
2896 u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK;
2897 u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT)
2898 & SND_BBFPRO_MIXER_VAL_MASK;
2899 return snd_bbfpro_vol_update(list->mixer, idx, val);
2900}
2901
2902// Predfine elements
2903static const struct snd_kcontrol_new snd_bbfpro_ctl_control = {
2904 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2905 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2906 .index = 0,
2907 .info = snd_bbfpro_ctl_info,
2908 .get = snd_bbfpro_ctl_get,
2909 .put = snd_bbfpro_ctl_put
2910};
2911
2912static const struct snd_kcontrol_new snd_bbfpro_gain_control = {
2913 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2914 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2915 .index = 0,
2916 .info = snd_bbfpro_gain_info,
2917 .get = snd_bbfpro_gain_get,
2918 .put = snd_bbfpro_gain_put
2919};
2920
2921static const struct snd_kcontrol_new snd_bbfpro_vol_control = {
2922 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2923 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2924 .index = 0,
2925 .info = snd_bbfpro_vol_info,
2926 .get = snd_bbfpro_vol_get,
2927 .put = snd_bbfpro_vol_put
2928};
2929
2930static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg,
2931 u8 index, char *name)
2932{
2933 struct snd_kcontrol_new knew = snd_bbfpro_ctl_control;
2934
2935 knew.name = name;
2936 knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK)
2937 | ((index & SND_BBFPRO_CTL_IDX_MASK)
2938 << SND_BBFPRO_CTL_IDX_SHIFT);
2939
2940 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume,
2941 &knew, NULL);
2942}
2943
2944static int snd_bbfpro_gain_add(struct usb_mixer_interface *mixer, u8 channel,
2945 char *name)
2946{
2947 struct snd_kcontrol_new knew = snd_bbfpro_gain_control;
2948
2949 knew.name = name;
2950 knew.private_value = channel << SND_BBFPRO_GAIN_CHANNEL_SHIFT;
2951
2952 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_gain_resume,
2953 &knew, NULL);
2954}
2955
2956static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index,
2957 char *name)
2958{
2959 struct snd_kcontrol_new knew = snd_bbfpro_vol_control;
2960
2961 knew.name = name;
2962 knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK;
2963
2964 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume,
2965 &knew, NULL);
2966}
2967
2968static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer)
2969{
2970 int err, i, o;
2971 char name[48];
2972
2973 static const char * const input[] = {
2974 "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3",
2975 "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2976
2977 static const char * const output[] = {
2978 "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4",
2979 "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2980
2981 for (o = 0 ; o < 12 ; ++o) {
2982 for (i = 0 ; i < 12 ; ++i) {
2983 // Line routing
2984 snprintf(name, sizeof(name),
2985 "%s-%s-%s Playback Volume",
2986 (i < 2 ? "Mic" : "Line"),
2987 input[i], output[o]);
2988 err = snd_bbfpro_vol_add(mixer, (26 * o + i), name);
2989 if (err < 0)
2990 return err;
2991
2992 // PCM routing... yes, it is output remapping
2993 snprintf(name, sizeof(name),
2994 "PCM-%s-%s Playback Volume",
2995 output[i], output[o]);
2996 err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i),
2997 name);
2998 if (err < 0)
2999 return err;
3000 }
3001 }
3002
3003 // Main out volume
3004 for (i = 0 ; i < 12 ; ++i) {
3005 snprintf(name, sizeof(name), "Main-Out %s", output[i]);
3006 // Main outs are offset to 992
3007 err = snd_bbfpro_vol_add(mixer,
3008 i + SND_BBFPRO_MIXER_MAIN_OUT_CH_OFFSET,
3009 name);
3010 if (err < 0)
3011 return err;
3012 }
3013
3014 // Input gain
3015 for (i = 0 ; i < 4 ; ++i) {
3016 if (i < 2)
3017 snprintf(name, sizeof(name), "Mic-%s Gain", input[i]);
3018 else
3019 snprintf(name, sizeof(name), "Line-%s Gain", input[i]);
3020
3021 err = snd_bbfpro_gain_add(mixer, i, name);
3022 if (err < 0)
3023 return err;
3024 }
3025
3026 // Control Reg 1
3027 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
3028 SND_BBFPRO_CTL_REG1_CLK_OPTICAL,
3029 "Sample Clock Source");
3030 if (err < 0)
3031 return err;
3032
3033 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
3034 SND_BBFPRO_CTL_REG1_SPDIF_PRO,
3035 "IEC958 Pro Mask");
3036 if (err < 0)
3037 return err;
3038
3039 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
3040 SND_BBFPRO_CTL_REG1_SPDIF_EMPH,
3041 "IEC958 Emphasis");
3042 if (err < 0)
3043 return err;
3044
3045 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
3046 SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL,
3047 "IEC958 Switch");
3048 if (err < 0)
3049 return err;
3050
3051 // Control Reg 2
3052 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
3053 SND_BBFPRO_CTL_REG2_48V_AN1,
3054 "Mic-AN1 48V");
3055 if (err < 0)
3056 return err;
3057
3058 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
3059 SND_BBFPRO_CTL_REG2_48V_AN2,
3060 "Mic-AN2 48V");
3061 if (err < 0)
3062 return err;
3063
3064 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
3065 SND_BBFPRO_CTL_REG2_SENS_IN3,
3066 "Line-IN3 Sens.");
3067 if (err < 0)
3068 return err;
3069
3070 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
3071 SND_BBFPRO_CTL_REG2_SENS_IN4,
3072 "Line-IN4 Sens.");
3073 if (err < 0)
3074 return err;
3075
3076 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
3077 SND_BBFPRO_CTL_REG2_PAD_AN1,
3078 "Mic-AN1 PAD");
3079 if (err < 0)
3080 return err;
3081
3082 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
3083 SND_BBFPRO_CTL_REG2_PAD_AN2,
3084 "Mic-AN2 PAD");
3085 if (err < 0)
3086 return err;
3087
3088 return 0;
3089}
3090
3091/*
3092 * RME Digiface USB
3093 */
3094
3095#define RME_DIGIFACE_READ_STATUS 17
3096#define RME_DIGIFACE_STATUS_REG0L 0
3097#define RME_DIGIFACE_STATUS_REG0H 1
3098#define RME_DIGIFACE_STATUS_REG1L 2
3099#define RME_DIGIFACE_STATUS_REG1H 3
3100#define RME_DIGIFACE_STATUS_REG2L 4
3101#define RME_DIGIFACE_STATUS_REG2H 5
3102#define RME_DIGIFACE_STATUS_REG3L 6
3103#define RME_DIGIFACE_STATUS_REG3H 7
3104
3105#define RME_DIGIFACE_CTL_REG1 16
3106#define RME_DIGIFACE_CTL_REG2 18
3107
3108/* Reg is overloaded, 0-7 for status halfwords or 16 or 18 for control registers */
3109#define RME_DIGIFACE_REGISTER(reg, mask) (((reg) << 16) | (mask))
3110#define RME_DIGIFACE_INVERT BIT(31)
3111
3112/* Nonconst helpers */
3113#define field_get(_mask, _reg) (((_reg) & (_mask)) >> (ffs(_mask) - 1))
3114#define field_prep(_mask, _val) (((_val) << (ffs(_mask) - 1)) & (_mask))
3115
3116static int snd_rme_digiface_write_reg(struct snd_kcontrol *kcontrol, int item, u16 mask, u16 val)
3117{
3118 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
3119 struct snd_usb_audio *chip = list->mixer->chip;
3120 struct usb_device *dev = chip->dev;
3121 int err;
3122
3123 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
3124 item,
3125 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
3126 val, mask, NULL, 0);
3127 if (err < 0)
3128 dev_err(&dev->dev,
3129 "unable to issue control set request %d (ret = %d)",
3130 item, err);
3131 return err;
3132}
3133
3134static int snd_rme_digiface_read_status(struct snd_kcontrol *kcontrol, u32 status[4])
3135{
3136 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
3137 struct snd_usb_audio *chip = list->mixer->chip;
3138 struct usb_device *dev = chip->dev;
3139 __le32 buf[4];
3140 int err;
3141
3142 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
3143 RME_DIGIFACE_READ_STATUS,
3144 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
3145 0, 0,
3146 buf, sizeof(buf));
3147 if (err < 0) {
3148 dev_err(&dev->dev,
3149 "unable to issue status read request (ret = %d)",
3150 err);
3151 } else {
3152 for (int i = 0; i < ARRAY_SIZE(buf); i++)
3153 status[i] = le32_to_cpu(buf[i]);
3154 }
3155 return err;
3156}
3157
3158static int snd_rme_digiface_get_status_val(struct snd_kcontrol *kcontrol)
3159{
3160 int err;
3161 u32 status[4];
3162 bool invert = kcontrol->private_value & RME_DIGIFACE_INVERT;
3163 u8 reg = (kcontrol->private_value >> 16) & 0xff;
3164 u16 mask = kcontrol->private_value & 0xffff;
3165 u16 val;
3166
3167 err = snd_rme_digiface_read_status(kcontrol, status);
3168 if (err < 0)
3169 return err;
3170
3171 switch (reg) {
3172 /* Status register halfwords */
3173 case RME_DIGIFACE_STATUS_REG0L ... RME_DIGIFACE_STATUS_REG3H:
3174 break;
3175 case RME_DIGIFACE_CTL_REG1: /* Control register 1, present in halfword 3L */
3176 reg = RME_DIGIFACE_STATUS_REG3L;
3177 break;
3178 case RME_DIGIFACE_CTL_REG2: /* Control register 2, present in halfword 3H */
3179 reg = RME_DIGIFACE_STATUS_REG3H;
3180 break;
3181 default:
3182 return -EINVAL;
3183 }
3184
3185 if (reg & 1)
3186 val = status[reg >> 1] >> 16;
3187 else
3188 val = status[reg >> 1] & 0xffff;
3189
3190 if (invert)
3191 val ^= mask;
3192
3193 return field_get(mask, val);
3194}
3195
3196static int snd_rme_digiface_rate_get(struct snd_kcontrol *kcontrol,
3197 struct snd_ctl_elem_value *ucontrol)
3198{
3199 int freq = snd_rme_digiface_get_status_val(kcontrol);
3200
3201 if (freq < 0)
3202 return freq;
3203 if (freq >= ARRAY_SIZE(snd_rme_rate_table))
3204 return -EIO;
3205
3206 ucontrol->value.integer.value[0] = snd_rme_rate_table[freq];
3207 return 0;
3208}
3209
3210static int snd_rme_digiface_enum_get(struct snd_kcontrol *kcontrol,
3211 struct snd_ctl_elem_value *ucontrol)
3212{
3213 int val = snd_rme_digiface_get_status_val(kcontrol);
3214
3215 if (val < 0)
3216 return val;
3217
3218 ucontrol->value.enumerated.item[0] = val;
3219 return 0;
3220}
3221
3222static int snd_rme_digiface_enum_put(struct snd_kcontrol *kcontrol,
3223 struct snd_ctl_elem_value *ucontrol)
3224{
3225 bool invert = kcontrol->private_value & RME_DIGIFACE_INVERT;
3226 u8 reg = (kcontrol->private_value >> 16) & 0xff;
3227 u16 mask = kcontrol->private_value & 0xffff;
3228 u16 val = field_prep(mask, ucontrol->value.enumerated.item[0]);
3229
3230 if (invert)
3231 val ^= mask;
3232
3233 return snd_rme_digiface_write_reg(kcontrol, reg, mask, val);
3234}
3235
3236static int snd_rme_digiface_current_sync_get(struct snd_kcontrol *kcontrol,
3237 struct snd_ctl_elem_value *ucontrol)
3238{
3239 int ret = snd_rme_digiface_enum_get(kcontrol, ucontrol);
3240
3241 /* 7 means internal for current sync */
3242 if (ucontrol->value.enumerated.item[0] == 7)
3243 ucontrol->value.enumerated.item[0] = 0;
3244
3245 return ret;
3246}
3247
3248static int snd_rme_digiface_sync_state_get(struct snd_kcontrol *kcontrol,
3249 struct snd_ctl_elem_value *ucontrol)
3250{
3251 u32 status[4];
3252 int err;
3253 bool valid, sync;
3254
3255 err = snd_rme_digiface_read_status(kcontrol, status);
3256 if (err < 0)
3257 return err;
3258
3259 valid = status[0] & BIT(kcontrol->private_value);
3260 sync = status[0] & BIT(5 + kcontrol->private_value);
3261
3262 if (!valid)
3263 ucontrol->value.enumerated.item[0] = SND_RME_CLOCK_NOLOCK;
3264 else if (!sync)
3265 ucontrol->value.enumerated.item[0] = SND_RME_CLOCK_LOCK;
3266 else
3267 ucontrol->value.enumerated.item[0] = SND_RME_CLOCK_SYNC;
3268 return 0;
3269}
3270
3271
3272static int snd_rme_digiface_format_info(struct snd_kcontrol *kcontrol,
3273 struct snd_ctl_elem_info *uinfo)
3274{
3275 static const char *const format[] = {
3276 "ADAT", "S/PDIF"
3277 };
3278
3279 return snd_ctl_enum_info(uinfo, 1,
3280 ARRAY_SIZE(format), format);
3281}
3282
3283
3284static int snd_rme_digiface_sync_source_info(struct snd_kcontrol *kcontrol,
3285 struct snd_ctl_elem_info *uinfo)
3286{
3287 static const char *const sync_sources[] = {
3288 "Internal", "Input 1", "Input 2", "Input 3", "Input 4"
3289 };
3290
3291 return snd_ctl_enum_info(uinfo, 1,
3292 ARRAY_SIZE(sync_sources), sync_sources);
3293}
3294
3295static int snd_rme_digiface_rate_info(struct snd_kcontrol *kcontrol,
3296 struct snd_ctl_elem_info *uinfo)
3297{
3298 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3299 uinfo->count = 1;
3300 uinfo->value.integer.min = 0;
3301 uinfo->value.integer.max = 200000;
3302 uinfo->value.integer.step = 0;
3303 return 0;
3304}
3305
3306static const struct snd_kcontrol_new snd_rme_digiface_controls[] = {
3307 {
3308 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3309 .name = "Input 1 Sync",
3310 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3311 .info = snd_rme_sync_state_info,
3312 .get = snd_rme_digiface_sync_state_get,
3313 .private_value = 0,
3314 },
3315 {
3316 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3317 .name = "Input 1 Format",
3318 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3319 .info = snd_rme_digiface_format_info,
3320 .get = snd_rme_digiface_enum_get,
3321 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG0H, BIT(0)) |
3322 RME_DIGIFACE_INVERT,
3323 },
3324 {
3325 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3326 .name = "Input 1 Rate",
3327 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3328 .info = snd_rme_digiface_rate_info,
3329 .get = snd_rme_digiface_rate_get,
3330 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG1L, GENMASK(3, 0)),
3331 },
3332 {
3333 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3334 .name = "Input 2 Sync",
3335 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3336 .info = snd_rme_sync_state_info,
3337 .get = snd_rme_digiface_sync_state_get,
3338 .private_value = 1,
3339 },
3340 {
3341 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3342 .name = "Input 2 Format",
3343 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3344 .info = snd_rme_digiface_format_info,
3345 .get = snd_rme_digiface_enum_get,
3346 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG0L, BIT(13)) |
3347 RME_DIGIFACE_INVERT,
3348 },
3349 {
3350 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3351 .name = "Input 2 Rate",
3352 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3353 .info = snd_rme_digiface_rate_info,
3354 .get = snd_rme_digiface_rate_get,
3355 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG1L, GENMASK(7, 4)),
3356 },
3357 {
3358 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3359 .name = "Input 3 Sync",
3360 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3361 .info = snd_rme_sync_state_info,
3362 .get = snd_rme_digiface_sync_state_get,
3363 .private_value = 2,
3364 },
3365 {
3366 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3367 .name = "Input 3 Format",
3368 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3369 .info = snd_rme_digiface_format_info,
3370 .get = snd_rme_digiface_enum_get,
3371 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG0L, BIT(14)) |
3372 RME_DIGIFACE_INVERT,
3373 },
3374 {
3375 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3376 .name = "Input 3 Rate",
3377 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3378 .info = snd_rme_digiface_rate_info,
3379 .get = snd_rme_digiface_rate_get,
3380 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG1L, GENMASK(11, 8)),
3381 },
3382 {
3383 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3384 .name = "Input 4 Sync",
3385 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3386 .info = snd_rme_sync_state_info,
3387 .get = snd_rme_digiface_sync_state_get,
3388 .private_value = 3,
3389 },
3390 {
3391 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3392 .name = "Input 4 Format",
3393 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3394 .info = snd_rme_digiface_format_info,
3395 .get = snd_rme_digiface_enum_get,
3396 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG0L, GENMASK(15, 12)) |
3397 RME_DIGIFACE_INVERT,
3398 },
3399 {
3400 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3401 .name = "Input 4 Rate",
3402 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3403 .info = snd_rme_digiface_rate_info,
3404 .get = snd_rme_digiface_rate_get,
3405 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG1L, GENMASK(3, 0)),
3406 },
3407 {
3408 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3409 .name = "Output 1 Format",
3410 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3411 .info = snd_rme_digiface_format_info,
3412 .get = snd_rme_digiface_enum_get,
3413 .put = snd_rme_digiface_enum_put,
3414 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_CTL_REG2, BIT(0)),
3415 },
3416 {
3417 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3418 .name = "Output 2 Format",
3419 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3420 .info = snd_rme_digiface_format_info,
3421 .get = snd_rme_digiface_enum_get,
3422 .put = snd_rme_digiface_enum_put,
3423 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_CTL_REG2, BIT(1)),
3424 },
3425 {
3426 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3427 .name = "Output 3 Format",
3428 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3429 .info = snd_rme_digiface_format_info,
3430 .get = snd_rme_digiface_enum_get,
3431 .put = snd_rme_digiface_enum_put,
3432 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_CTL_REG2, BIT(3)),
3433 },
3434 {
3435 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3436 .name = "Output 4 Format",
3437 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3438 .info = snd_rme_digiface_format_info,
3439 .get = snd_rme_digiface_enum_get,
3440 .put = snd_rme_digiface_enum_put,
3441 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_CTL_REG2, BIT(4)),
3442 },
3443 {
3444 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3445 .name = "Sync Source",
3446 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3447 .info = snd_rme_digiface_sync_source_info,
3448 .get = snd_rme_digiface_enum_get,
3449 .put = snd_rme_digiface_enum_put,
3450 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_CTL_REG1, GENMASK(2, 0)),
3451 },
3452 {
3453 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3454 .name = "Current Sync Source",
3455 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3456 .info = snd_rme_digiface_sync_source_info,
3457 .get = snd_rme_digiface_current_sync_get,
3458 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG0L, GENMASK(12, 10)),
3459 },
3460 {
3461 /*
3462 * This is writeable, but it is only set by the PCM rate.
3463 * Mixer apps currently need to drive the mixer using raw USB requests,
3464 * so they can also change this that way to configure the rate for
3465 * stand-alone operation when the PCM is closed.
3466 */
3467 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3468 .name = "System Rate",
3469 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3470 .info = snd_rme_rate_info,
3471 .get = snd_rme_digiface_rate_get,
3472 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_CTL_REG1, GENMASK(6, 3)),
3473 },
3474 {
3475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3476 .name = "Current Rate",
3477 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3478 .info = snd_rme_rate_info,
3479 .get = snd_rme_digiface_rate_get,
3480 .private_value = RME_DIGIFACE_REGISTER(RME_DIGIFACE_STATUS_REG1H, GENMASK(7, 4)),
3481 }
3482};
3483
3484static int snd_rme_digiface_controls_create(struct usb_mixer_interface *mixer)
3485{
3486 int err, i;
3487
3488 for (i = 0; i < ARRAY_SIZE(snd_rme_digiface_controls); ++i) {
3489 err = add_single_ctl_with_resume(mixer, 0,
3490 NULL,
3491 &snd_rme_digiface_controls[i],
3492 NULL);
3493 if (err < 0)
3494 return err;
3495 }
3496
3497 return 0;
3498}
3499
3500/*
3501 * Pioneer DJ / AlphaTheta DJM Mixers
3502 *
3503 * These devices generally have options for soft-switching the playback and
3504 * capture sources in addition to the recording level. Although different
3505 * devices have different configurations, there seems to be canonical values
3506 * for specific capture/playback types: See the definitions of these below.
3507 *
3508 * The wValue is masked with the stereo channel number. e.g. Setting Ch2 to
3509 * capture phono would be 0x0203. Capture, playback and capture level have
3510 * different wIndexes.
3511 */
3512
3513// Capture types
3514#define SND_DJM_CAP_LINE 0x00
3515#define SND_DJM_CAP_CDLINE 0x01
3516#define SND_DJM_CAP_DIGITAL 0x02
3517#define SND_DJM_CAP_PHONO 0x03
3518#define SND_DJM_CAP_PREFADER 0x05
3519#define SND_DJM_CAP_PFADER 0x06
3520#define SND_DJM_CAP_XFADERA 0x07
3521#define SND_DJM_CAP_XFADERB 0x08
3522#define SND_DJM_CAP_MIC 0x09
3523#define SND_DJM_CAP_AUX 0x0d
3524#define SND_DJM_CAP_RECOUT 0x0a
3525#define SND_DJM_CAP_RECOUT_NOMIC 0x0e
3526#define SND_DJM_CAP_NONE 0x0f
3527#define SND_DJM_CAP_CH1PFADER 0x11
3528#define SND_DJM_CAP_CH2PFADER 0x12
3529#define SND_DJM_CAP_CH3PFADER 0x13
3530#define SND_DJM_CAP_CH4PFADER 0x14
3531#define SND_DJM_CAP_CH1PREFADER 0x31
3532#define SND_DJM_CAP_CH2PREFADER 0x32
3533#define SND_DJM_CAP_CH3PREFADER 0x33
3534#define SND_DJM_CAP_CH4PREFADER 0x34
3535
3536// Playback types
3537#define SND_DJM_PB_CH1 0x00
3538#define SND_DJM_PB_CH2 0x01
3539#define SND_DJM_PB_AUX 0x04
3540
3541#define SND_DJM_WINDEX_CAP 0x8002
3542#define SND_DJM_WINDEX_CAPLVL 0x8003
3543#define SND_DJM_WINDEX_PB 0x8016
3544
3545// kcontrol->private_value layout
3546#define SND_DJM_VALUE_MASK 0x0000ffff
3547#define SND_DJM_GROUP_MASK 0x00ff0000
3548#define SND_DJM_DEVICE_MASK 0xff000000
3549#define SND_DJM_GROUP_SHIFT 16
3550#define SND_DJM_DEVICE_SHIFT 24
3551
3552// device table index
3553// used for the snd_djm_devices table, so please update accordingly
3554#define SND_DJM_250MK2_IDX 0x0
3555#define SND_DJM_750_IDX 0x1
3556#define SND_DJM_850_IDX 0x2
3557#define SND_DJM_900NXS2_IDX 0x3
3558#define SND_DJM_750MK2_IDX 0x4
3559#define SND_DJM_450_IDX 0x5
3560#define SND_DJM_A9_IDX 0x6
3561
3562
3563#define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \
3564 .name = _name, \
3565 .options = snd_djm_opts_##suffix, \
3566 .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \
3567 .default_value = _default_value, \
3568 .wIndex = _windex }
3569
3570#define SND_DJM_DEVICE(suffix) { \
3571 .controls = snd_djm_ctls_##suffix, \
3572 .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) }
3573
3574
3575struct snd_djm_device {
3576 const char *name;
3577 const struct snd_djm_ctl *controls;
3578 size_t ncontrols;
3579};
3580
3581struct snd_djm_ctl {
3582 const char *name;
3583 const u16 *options;
3584 size_t noptions;
3585 u16 default_value;
3586 u16 wIndex;
3587};
3588
3589static const char *snd_djm_get_label_caplevel_common(u16 wvalue)
3590{
3591 switch (wvalue) {
3592 case 0x0000: return "-19dB";
3593 case 0x0100: return "-15dB";
3594 case 0x0200: return "-10dB";
3595 case 0x0300: return "-5dB";
3596 default: return NULL;
3597 }
3598};
3599
3600// The DJM-A9 has different capture levels than other, older models
3601static const char *snd_djm_get_label_caplevel_a9(u16 wvalue)
3602{
3603 switch (wvalue) {
3604 case 0x0000: return "+15dB";
3605 case 0x0100: return "+12dB";
3606 case 0x0200: return "+9dB";
3607 case 0x0300: return "+6dB";
3608 case 0x0400: return "+3dB";
3609 case 0x0500: return "0dB";
3610 default: return NULL;
3611 }
3612};
3613
3614static const char *snd_djm_get_label_cap_common(u16 wvalue)
3615{
3616 switch (wvalue & 0x00ff) {
3617 case SND_DJM_CAP_LINE: return "Control Tone LINE";
3618 case SND_DJM_CAP_CDLINE: return "Control Tone CD/LINE";
3619 case SND_DJM_CAP_DIGITAL: return "Control Tone DIGITAL";
3620 case SND_DJM_CAP_PHONO: return "Control Tone PHONO";
3621 case SND_DJM_CAP_PFADER: return "Post Fader";
3622 case SND_DJM_CAP_XFADERA: return "Cross Fader A";
3623 case SND_DJM_CAP_XFADERB: return "Cross Fader B";
3624 case SND_DJM_CAP_MIC: return "Mic";
3625 case SND_DJM_CAP_RECOUT: return "Rec Out";
3626 case SND_DJM_CAP_RECOUT_NOMIC: return "Rec Out without Mic";
3627 case SND_DJM_CAP_AUX: return "Aux";
3628 case SND_DJM_CAP_NONE: return "None";
3629 case SND_DJM_CAP_CH1PREFADER: return "Pre Fader Ch1";
3630 case SND_DJM_CAP_CH2PREFADER: return "Pre Fader Ch2";
3631 case SND_DJM_CAP_CH3PREFADER: return "Pre Fader Ch3";
3632 case SND_DJM_CAP_CH4PREFADER: return "Pre Fader Ch4";
3633 case SND_DJM_CAP_CH1PFADER: return "Post Fader Ch1";
3634 case SND_DJM_CAP_CH2PFADER: return "Post Fader Ch2";
3635 case SND_DJM_CAP_CH3PFADER: return "Post Fader Ch3";
3636 case SND_DJM_CAP_CH4PFADER: return "Post Fader Ch4";
3637 default: return NULL;
3638 }
3639};
3640
3641// The DJM-850 has different values for CD/LINE and LINE capture
3642// control options than the other DJM declared in this file.
3643static const char *snd_djm_get_label_cap_850(u16 wvalue)
3644{
3645 switch (wvalue & 0x00ff) {
3646 case 0x00: return "Control Tone CD/LINE";
3647 case 0x01: return "Control Tone LINE";
3648 default: return snd_djm_get_label_cap_common(wvalue);
3649 }
3650};
3651
3652static const char *snd_djm_get_label_caplevel(u8 device_idx, u16 wvalue)
3653{
3654 switch (device_idx) {
3655 case SND_DJM_A9_IDX: return snd_djm_get_label_caplevel_a9(wvalue);
3656 default: return snd_djm_get_label_caplevel_common(wvalue);
3657 }
3658};
3659
3660static const char *snd_djm_get_label_cap(u8 device_idx, u16 wvalue)
3661{
3662 switch (device_idx) {
3663 case SND_DJM_850_IDX: return snd_djm_get_label_cap_850(wvalue);
3664 default: return snd_djm_get_label_cap_common(wvalue);
3665 }
3666};
3667
3668static const char *snd_djm_get_label_pb(u16 wvalue)
3669{
3670 switch (wvalue & 0x00ff) {
3671 case SND_DJM_PB_CH1: return "Ch1";
3672 case SND_DJM_PB_CH2: return "Ch2";
3673 case SND_DJM_PB_AUX: return "Aux";
3674 default: return NULL;
3675 }
3676};
3677
3678static const char *snd_djm_get_label(u8 device_idx, u16 wvalue, u16 windex)
3679{
3680 switch (windex) {
3681 case SND_DJM_WINDEX_CAPLVL: return snd_djm_get_label_caplevel(device_idx, wvalue);
3682 case SND_DJM_WINDEX_CAP: return snd_djm_get_label_cap(device_idx, wvalue);
3683 case SND_DJM_WINDEX_PB: return snd_djm_get_label_pb(wvalue);
3684 default: return NULL;
3685 }
3686};
3687
3688// common DJM capture level option values
3689static const u16 snd_djm_opts_cap_level[] = {
3690 0x0000, 0x0100, 0x0200, 0x0300, 0x400, 0x500 };
3691
3692
3693// DJM-250MK2
3694static const u16 snd_djm_opts_250mk2_cap1[] = {
3695 0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a };
3696
3697static const u16 snd_djm_opts_250mk2_cap2[] = {
3698 0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a };
3699
3700static const u16 snd_djm_opts_250mk2_cap3[] = {
3701 0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d };
3702
3703static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 };
3704static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 };
3705static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 };
3706
3707static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = {
3708 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3709 SND_DJM_CTL("Ch1 Input", 250mk2_cap1, 2, SND_DJM_WINDEX_CAP),
3710 SND_DJM_CTL("Ch2 Input", 250mk2_cap2, 2, SND_DJM_WINDEX_CAP),
3711 SND_DJM_CTL("Ch3 Input", 250mk2_cap3, 0, SND_DJM_WINDEX_CAP),
3712 SND_DJM_CTL("Ch1 Output", 250mk2_pb1, 0, SND_DJM_WINDEX_PB),
3713 SND_DJM_CTL("Ch2 Output", 250mk2_pb2, 1, SND_DJM_WINDEX_PB),
3714 SND_DJM_CTL("Ch3 Output", 250mk2_pb3, 2, SND_DJM_WINDEX_PB)
3715};
3716
3717
3718// DJM-450
3719static const u16 snd_djm_opts_450_cap1[] = {
3720 0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a };
3721
3722static const u16 snd_djm_opts_450_cap2[] = {
3723 0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a };
3724
3725static const u16 snd_djm_opts_450_cap3[] = {
3726 0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d };
3727
3728static const u16 snd_djm_opts_450_pb1[] = { 0x0100, 0x0101, 0x0104 };
3729static const u16 snd_djm_opts_450_pb2[] = { 0x0200, 0x0201, 0x0204 };
3730static const u16 snd_djm_opts_450_pb3[] = { 0x0300, 0x0301, 0x0304 };
3731
3732static const struct snd_djm_ctl snd_djm_ctls_450[] = {
3733 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3734 SND_DJM_CTL("Ch1 Input", 450_cap1, 2, SND_DJM_WINDEX_CAP),
3735 SND_DJM_CTL("Ch2 Input", 450_cap2, 2, SND_DJM_WINDEX_CAP),
3736 SND_DJM_CTL("Ch3 Input", 450_cap3, 0, SND_DJM_WINDEX_CAP),
3737 SND_DJM_CTL("Ch1 Output", 450_pb1, 0, SND_DJM_WINDEX_PB),
3738 SND_DJM_CTL("Ch2 Output", 450_pb2, 1, SND_DJM_WINDEX_PB),
3739 SND_DJM_CTL("Ch3 Output", 450_pb3, 2, SND_DJM_WINDEX_PB)
3740};
3741
3742
3743// DJM-750
3744static const u16 snd_djm_opts_750_cap1[] = {
3745 0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
3746static const u16 snd_djm_opts_750_cap2[] = {
3747 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
3748static const u16 snd_djm_opts_750_cap3[] = {
3749 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
3750static const u16 snd_djm_opts_750_cap4[] = {
3751 0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
3752
3753static const struct snd_djm_ctl snd_djm_ctls_750[] = {
3754 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3755 SND_DJM_CTL("Ch1 Input", 750_cap1, 2, SND_DJM_WINDEX_CAP),
3756 SND_DJM_CTL("Ch2 Input", 750_cap2, 2, SND_DJM_WINDEX_CAP),
3757 SND_DJM_CTL("Ch3 Input", 750_cap3, 0, SND_DJM_WINDEX_CAP),
3758 SND_DJM_CTL("Ch4 Input", 750_cap4, 0, SND_DJM_WINDEX_CAP)
3759};
3760
3761
3762// DJM-850
3763static const u16 snd_djm_opts_850_cap1[] = {
3764 0x0100, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
3765static const u16 snd_djm_opts_850_cap2[] = {
3766 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
3767static const u16 snd_djm_opts_850_cap3[] = {
3768 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
3769static const u16 snd_djm_opts_850_cap4[] = {
3770 0x0400, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
3771
3772static const struct snd_djm_ctl snd_djm_ctls_850[] = {
3773 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3774 SND_DJM_CTL("Ch1 Input", 850_cap1, 1, SND_DJM_WINDEX_CAP),
3775 SND_DJM_CTL("Ch2 Input", 850_cap2, 0, SND_DJM_WINDEX_CAP),
3776 SND_DJM_CTL("Ch3 Input", 850_cap3, 0, SND_DJM_WINDEX_CAP),
3777 SND_DJM_CTL("Ch4 Input", 850_cap4, 1, SND_DJM_WINDEX_CAP)
3778};
3779
3780
3781// DJM-900NXS2
3782static const u16 snd_djm_opts_900nxs2_cap1[] = {
3783 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a };
3784static const u16 snd_djm_opts_900nxs2_cap2[] = {
3785 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a };
3786static const u16 snd_djm_opts_900nxs2_cap3[] = {
3787 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a };
3788static const u16 snd_djm_opts_900nxs2_cap4[] = {
3789 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a };
3790static const u16 snd_djm_opts_900nxs2_cap5[] = {
3791 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 };
3792
3793static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = {
3794 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3795 SND_DJM_CTL("Ch1 Input", 900nxs2_cap1, 2, SND_DJM_WINDEX_CAP),
3796 SND_DJM_CTL("Ch2 Input", 900nxs2_cap2, 2, SND_DJM_WINDEX_CAP),
3797 SND_DJM_CTL("Ch3 Input", 900nxs2_cap3, 2, SND_DJM_WINDEX_CAP),
3798 SND_DJM_CTL("Ch4 Input", 900nxs2_cap4, 2, SND_DJM_WINDEX_CAP),
3799 SND_DJM_CTL("Ch5 Input", 900nxs2_cap5, 3, SND_DJM_WINDEX_CAP)
3800};
3801
3802// DJM-750MK2
3803static const u16 snd_djm_opts_750mk2_cap1[] = {
3804 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a };
3805static const u16 snd_djm_opts_750mk2_cap2[] = {
3806 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a };
3807static const u16 snd_djm_opts_750mk2_cap3[] = {
3808 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a };
3809static const u16 snd_djm_opts_750mk2_cap4[] = {
3810 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a };
3811static const u16 snd_djm_opts_750mk2_cap5[] = {
3812 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 };
3813
3814static const u16 snd_djm_opts_750mk2_pb1[] = { 0x0100, 0x0101, 0x0104 };
3815static const u16 snd_djm_opts_750mk2_pb2[] = { 0x0200, 0x0201, 0x0204 };
3816static const u16 snd_djm_opts_750mk2_pb3[] = { 0x0300, 0x0301, 0x0304 };
3817
3818
3819static const struct snd_djm_ctl snd_djm_ctls_750mk2[] = {
3820 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3821 SND_DJM_CTL("Ch1 Input", 750mk2_cap1, 2, SND_DJM_WINDEX_CAP),
3822 SND_DJM_CTL("Ch2 Input", 750mk2_cap2, 2, SND_DJM_WINDEX_CAP),
3823 SND_DJM_CTL("Ch3 Input", 750mk2_cap3, 2, SND_DJM_WINDEX_CAP),
3824 SND_DJM_CTL("Ch4 Input", 750mk2_cap4, 2, SND_DJM_WINDEX_CAP),
3825 SND_DJM_CTL("Ch5 Input", 750mk2_cap5, 3, SND_DJM_WINDEX_CAP),
3826 SND_DJM_CTL("Ch1 Output", 750mk2_pb1, 0, SND_DJM_WINDEX_PB),
3827 SND_DJM_CTL("Ch2 Output", 750mk2_pb2, 1, SND_DJM_WINDEX_PB),
3828 SND_DJM_CTL("Ch3 Output", 750mk2_pb3, 2, SND_DJM_WINDEX_PB)
3829};
3830
3831
3832// DJM-A9
3833static const u16 snd_djm_opts_a9_cap1[] = {
3834 0x0107, 0x0108, 0x0109, 0x010a, 0x010e,
3835 0x111, 0x112, 0x113, 0x114, 0x0131, 0x132, 0x133, 0x134 };
3836static const u16 snd_djm_opts_a9_cap2[] = {
3837 0x0201, 0x0202, 0x0203, 0x0205, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020e };
3838static const u16 snd_djm_opts_a9_cap3[] = {
3839 0x0301, 0x0302, 0x0303, 0x0305, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030e };
3840static const u16 snd_djm_opts_a9_cap4[] = {
3841 0x0401, 0x0402, 0x0403, 0x0405, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040e };
3842static const u16 snd_djm_opts_a9_cap5[] = {
3843 0x0501, 0x0502, 0x0503, 0x0505, 0x0506, 0x0507, 0x0508, 0x0509, 0x050a, 0x050e };
3844
3845static const struct snd_djm_ctl snd_djm_ctls_a9[] = {
3846 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3847 SND_DJM_CTL("Master Input", a9_cap1, 3, SND_DJM_WINDEX_CAP),
3848 SND_DJM_CTL("Ch1 Input", a9_cap2, 2, SND_DJM_WINDEX_CAP),
3849 SND_DJM_CTL("Ch2 Input", a9_cap3, 2, SND_DJM_WINDEX_CAP),
3850 SND_DJM_CTL("Ch3 Input", a9_cap4, 2, SND_DJM_WINDEX_CAP),
3851 SND_DJM_CTL("Ch4 Input", a9_cap5, 2, SND_DJM_WINDEX_CAP)
3852};
3853
3854static const struct snd_djm_device snd_djm_devices[] = {
3855 [SND_DJM_250MK2_IDX] = SND_DJM_DEVICE(250mk2),
3856 [SND_DJM_750_IDX] = SND_DJM_DEVICE(750),
3857 [SND_DJM_850_IDX] = SND_DJM_DEVICE(850),
3858 [SND_DJM_900NXS2_IDX] = SND_DJM_DEVICE(900nxs2),
3859 [SND_DJM_750MK2_IDX] = SND_DJM_DEVICE(750mk2),
3860 [SND_DJM_450_IDX] = SND_DJM_DEVICE(450),
3861 [SND_DJM_A9_IDX] = SND_DJM_DEVICE(a9),
3862};
3863
3864
3865static int snd_djm_controls_info(struct snd_kcontrol *kctl,
3866 struct snd_ctl_elem_info *info)
3867{
3868 unsigned long private_value = kctl->private_value;
3869 u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3870 u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3871 const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3872 const char *name;
3873 const struct snd_djm_ctl *ctl;
3874 size_t noptions;
3875
3876 if (ctl_idx >= device->ncontrols)
3877 return -EINVAL;
3878
3879 ctl = &device->controls[ctl_idx];
3880 noptions = ctl->noptions;
3881 if (info->value.enumerated.item >= noptions)
3882 info->value.enumerated.item = noptions - 1;
3883
3884 name = snd_djm_get_label(device_idx,
3885 ctl->options[info->value.enumerated.item],
3886 ctl->wIndex);
3887 if (!name)
3888 return -EINVAL;
3889
3890 strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name));
3891 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3892 info->count = 1;
3893 info->value.enumerated.items = noptions;
3894 return 0;
3895}
3896
3897static int snd_djm_controls_update(struct usb_mixer_interface *mixer,
3898 u8 device_idx, u8 group, u16 value)
3899{
3900 int err;
3901 const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3902
3903 if ((group >= device->ncontrols) || value >= device->controls[group].noptions)
3904 return -EINVAL;
3905
3906 err = snd_usb_lock_shutdown(mixer->chip);
3907 if (err)
3908 return err;
3909
3910 err = snd_usb_ctl_msg(
3911 mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0),
3912 USB_REQ_SET_FEATURE,
3913 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
3914 device->controls[group].options[value],
3915 device->controls[group].wIndex,
3916 NULL, 0);
3917
3918 snd_usb_unlock_shutdown(mixer->chip);
3919 return err;
3920}
3921
3922static int snd_djm_controls_get(struct snd_kcontrol *kctl,
3923 struct snd_ctl_elem_value *elem)
3924{
3925 elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK;
3926 return 0;
3927}
3928
3929static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem)
3930{
3931 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
3932 struct usb_mixer_interface *mixer = list->mixer;
3933 unsigned long private_value = kctl->private_value;
3934
3935 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3936 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3937 u16 value = elem->value.enumerated.item[0];
3938
3939 kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) |
3940 (group << SND_DJM_GROUP_SHIFT) |
3941 value);
3942
3943 return snd_djm_controls_update(mixer, device, group, value);
3944}
3945
3946static int snd_djm_controls_resume(struct usb_mixer_elem_list *list)
3947{
3948 unsigned long private_value = list->kctl->private_value;
3949 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3950 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3951 u16 value = (private_value & SND_DJM_VALUE_MASK);
3952
3953 return snd_djm_controls_update(list->mixer, device, group, value);
3954}
3955
3956static int snd_djm_controls_create(struct usb_mixer_interface *mixer,
3957 const u8 device_idx)
3958{
3959 int err, i;
3960 u16 value;
3961
3962 const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3963
3964 struct snd_kcontrol_new knew = {
3965 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3966 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3967 .index = 0,
3968 .info = snd_djm_controls_info,
3969 .get = snd_djm_controls_get,
3970 .put = snd_djm_controls_put
3971 };
3972
3973 for (i = 0; i < device->ncontrols; i++) {
3974 value = device->controls[i].default_value;
3975 knew.name = device->controls[i].name;
3976 knew.private_value = (
3977 ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) |
3978 (i << SND_DJM_GROUP_SHIFT) |
3979 value);
3980 err = snd_djm_controls_update(mixer, device_idx, i, value);
3981 if (err)
3982 return err;
3983 err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume,
3984 &knew, NULL);
3985 if (err)
3986 return err;
3987 }
3988 return 0;
3989}
3990
3991int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
3992{
3993 int err = 0;
3994
3995 err = snd_usb_soundblaster_remote_init(mixer);
3996 if (err < 0)
3997 return err;
3998
3999 switch (mixer->chip->usb_id) {
4000 /* Tascam US-16x08 */
4001 case USB_ID(0x0644, 0x8047):
4002 err = snd_us16x08_controls_create(mixer);
4003 break;
4004 case USB_ID(0x041e, 0x3020):
4005 case USB_ID(0x041e, 0x3040):
4006 case USB_ID(0x041e, 0x3042):
4007 case USB_ID(0x041e, 0x30df):
4008 case USB_ID(0x041e, 0x3048):
4009 err = snd_audigy2nx_controls_create(mixer);
4010 if (err < 0)
4011 break;
4012 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx",
4013 mixer, snd_audigy2nx_proc_read);
4014 break;
4015
4016 /* EMU0204 */
4017 case USB_ID(0x041e, 0x3f19):
4018 err = snd_emu0204_controls_create(mixer);
4019 break;
4020
4021 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
4022 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
4023 err = snd_c400_create_mixer(mixer);
4024 break;
4025
4026 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
4027 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
4028 err = snd_ftu_create_mixer(mixer);
4029 break;
4030
4031 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
4032 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
4033 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
4034 err = snd_xonar_u1_controls_create(mixer);
4035 break;
4036
4037 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
4038 err = snd_microii_controls_create(mixer);
4039 break;
4040
4041 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */
4042 err = snd_mbox1_controls_create(mixer);
4043 break;
4044
4045 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
4046 err = snd_nativeinstruments_create_mixer(mixer,
4047 snd_nativeinstruments_ta6_mixers,
4048 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
4049 break;
4050
4051 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
4052 err = snd_nativeinstruments_create_mixer(mixer,
4053 snd_nativeinstruments_ta10_mixers,
4054 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
4055 break;
4056
4057 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
4058 /* detection is disabled in mixer_maps.c */
4059 err = snd_create_std_mono_table(mixer, ebox44_table);
4060 break;
4061
4062 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */
4063 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */
4064 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */
4065 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */
4066 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */
4067 err = snd_scarlett_controls_create(mixer);
4068 break;
4069
4070 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
4071 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
4072 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
4073 case USB_ID(0x1235, 0x8211): /* Focusrite Scarlett Solo 3rd Gen */
4074 case USB_ID(0x1235, 0x8210): /* Focusrite Scarlett 2i2 3rd Gen */
4075 case USB_ID(0x1235, 0x8212): /* Focusrite Scarlett 4i4 3rd Gen */
4076 case USB_ID(0x1235, 0x8213): /* Focusrite Scarlett 8i6 3rd Gen */
4077 case USB_ID(0x1235, 0x8214): /* Focusrite Scarlett 18i8 3rd Gen */
4078 case USB_ID(0x1235, 0x8215): /* Focusrite Scarlett 18i20 3rd Gen */
4079 case USB_ID(0x1235, 0x8216): /* Focusrite Vocaster One */
4080 case USB_ID(0x1235, 0x8217): /* Focusrite Vocaster Two */
4081 case USB_ID(0x1235, 0x8218): /* Focusrite Scarlett Solo 4th Gen */
4082 case USB_ID(0x1235, 0x8219): /* Focusrite Scarlett 2i2 4th Gen */
4083 case USB_ID(0x1235, 0x821a): /* Focusrite Scarlett 4i4 4th Gen */
4084 case USB_ID(0x1235, 0x8206): /* Focusrite Clarett 2Pre USB */
4085 case USB_ID(0x1235, 0x8207): /* Focusrite Clarett 4Pre USB */
4086 case USB_ID(0x1235, 0x8208): /* Focusrite Clarett 8Pre USB */
4087 case USB_ID(0x1235, 0x820a): /* Focusrite Clarett+ 2Pre */
4088 case USB_ID(0x1235, 0x820b): /* Focusrite Clarett+ 4Pre */
4089 case USB_ID(0x1235, 0x820c): /* Focusrite Clarett+ 8Pre */
4090 err = snd_scarlett2_init(mixer);
4091 break;
4092
4093 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
4094 err = snd_soundblaster_e1_switch_create(mixer);
4095 break;
4096 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
4097 err = dell_dock_mixer_create(mixer);
4098 if (err < 0)
4099 break;
4100 err = dell_dock_mixer_init(mixer);
4101 break;
4102 case USB_ID(0x0bda, 0x402e): /* Dell WD19 dock */
4103 err = dell_dock_mixer_create(mixer);
4104 break;
4105
4106 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */
4107 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */
4108 case USB_ID(0x2a39, 0x3fd4): /* RME */
4109 err = snd_rme_controls_create(mixer);
4110 break;
4111
4112 case USB_ID(0x194f, 0x010c): /* Presonus Studio 1810c */
4113 err = snd_sc1810_init_mixer(mixer);
4114 break;
4115 case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */
4116 err = snd_bbfpro_controls_create(mixer);
4117 break;
4118 case USB_ID(0x2a39, 0x3f8c): /* RME Digiface USB */
4119 case USB_ID(0x2a39, 0x3fa0): /* RME Digiface USB (alternate) */
4120 err = snd_rme_digiface_controls_create(mixer);
4121 break;
4122 case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */
4123 err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX);
4124 break;
4125 case USB_ID(0x2b73, 0x0013): /* Pioneer DJ DJM-450 */
4126 err = snd_djm_controls_create(mixer, SND_DJM_450_IDX);
4127 break;
4128 case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */
4129 err = snd_djm_controls_create(mixer, SND_DJM_750_IDX);
4130 break;
4131 case USB_ID(0x2b73, 0x001b): /* Pioneer DJ DJM-750MK2 */
4132 err = snd_djm_controls_create(mixer, SND_DJM_750MK2_IDX);
4133 break;
4134 case USB_ID(0x08e4, 0x0163): /* Pioneer DJ DJM-850 */
4135 err = snd_djm_controls_create(mixer, SND_DJM_850_IDX);
4136 break;
4137 case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */
4138 err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX);
4139 break;
4140 case USB_ID(0x2b73, 0x003c): /* Pioneer DJ / AlphaTheta DJM-A9 */
4141 err = snd_djm_controls_create(mixer, SND_DJM_A9_IDX);
4142 break;
4143 }
4144
4145 return err;
4146}
4147
4148void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
4149{
4150 switch (mixer->chip->usb_id) {
4151 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
4152 dell_dock_mixer_init(mixer);
4153 break;
4154 }
4155}
4156
4157void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
4158 int unitid)
4159{
4160 if (!mixer->rc_cfg)
4161 return;
4162 /* unit ids specific to Extigy/Audigy 2 NX: */
4163 switch (unitid) {
4164 case 0: /* remote control */
4165 mixer->rc_urb->dev = mixer->chip->dev;
4166 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
4167 break;
4168 case 4: /* digital in jack */
4169 case 7: /* line in jacks */
4170 case 19: /* speaker out jacks */
4171 case 20: /* headphones out jack */
4172 break;
4173 /* live24ext: 4 = line-in jack */
4174 case 3: /* hp-out jack (may actuate Mute) */
4175 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
4176 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
4177 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
4178 break;
4179 default:
4180 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
4181 break;
4182 }
4183}
4184
4185static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
4186 struct usb_mixer_elem_info *cval,
4187 struct snd_kcontrol *kctl)
4188{
4189 /* Approximation using 10 ranges based on output measurement on hw v1.2.
4190 * This seems close to the cubic mapping e.g. alsamixer uses. */
4191 static const DECLARE_TLV_DB_RANGE(scale,
4192 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970),
4193 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160),
4194 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710),
4195 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560),
4196 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324),
4197 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031),
4198 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393),
4199 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032),
4200 32, 40, TLV_DB_MINMAX_ITEM(-968, -490),
4201 41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
4202 );
4203
4204 if (cval->min == 0 && cval->max == 50) {
4205 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
4206 kctl->tlv.p = scale;
4207 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
4208 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
4209
4210 } else if (cval->min == 0 && cval->max <= 1000) {
4211 /* Some other clearly broken DragonFly variant.
4212 * At least a 0..53 variant (hw v1.0) exists.
4213 */
4214 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
4215 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
4216 }
4217}
4218
4219void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
4220 struct usb_mixer_elem_info *cval, int unitid,
4221 struct snd_kcontrol *kctl)
4222{
4223 switch (mixer->chip->usb_id) {
4224 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
4225 if (unitid == 7 && cval->control == UAC_FU_VOLUME)
4226 snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
4227 break;
4228 /* lowest playback value is muted on some devices */
4229 case USB_ID(0x0d8c, 0x000c): /* C-Media */
4230 case USB_ID(0x0d8c, 0x0014): /* C-Media */
4231 case USB_ID(0x19f7, 0x0003): /* RODE NT-USB */
4232 if (strstr(kctl->id.name, "Playback"))
4233 cval->min_mute = 1;
4234 break;
4235 }
4236}
4237
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * USB Audio Driver for ALSA
4 *
5 * Quirks and vendor-specific extensions for mixer interfaces
6 *
7 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
8 *
9 * Many codes borrowed from audio.c by
10 * Alan Cox (alan@lxorguk.ukuu.org.uk)
11 * Thomas Sailer (sailer@ife.ee.ethz.ch)
12 *
13 * Audio Advantage Micro II support added by:
14 * Przemek Rudy (prudy1@o2.pl)
15 */
16
17#include <linux/hid.h>
18#include <linux/init.h>
19#include <linux/math64.h>
20#include <linux/slab.h>
21#include <linux/usb.h>
22#include <linux/usb/audio.h>
23
24#include <sound/asoundef.h>
25#include <sound/core.h>
26#include <sound/control.h>
27#include <sound/hwdep.h>
28#include <sound/info.h>
29#include <sound/tlv.h>
30
31#include "usbaudio.h"
32#include "mixer.h"
33#include "mixer_quirks.h"
34#include "mixer_scarlett.h"
35#include "mixer_scarlett_gen2.h"
36#include "mixer_us16x08.h"
37#include "helper.h"
38
39struct std_mono_table {
40 unsigned int unitid, control, cmask;
41 int val_type;
42 const char *name;
43 snd_kcontrol_tlv_rw_t *tlv_callback;
44};
45
46/* This function allows for the creation of standard UAC controls.
47 * See the quirks for M-Audio FTUs or Ebox-44.
48 * If you don't want to set a TLV callback pass NULL.
49 *
50 * Since there doesn't seem to be a devices that needs a multichannel
51 * version, we keep it mono for simplicity.
52 */
53static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
54 unsigned int unitid,
55 unsigned int control,
56 unsigned int cmask,
57 int val_type,
58 unsigned int idx_off,
59 const char *name,
60 snd_kcontrol_tlv_rw_t *tlv_callback)
61{
62 struct usb_mixer_elem_info *cval;
63 struct snd_kcontrol *kctl;
64
65 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
66 if (!cval)
67 return -ENOMEM;
68
69 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
70 cval->val_type = val_type;
71 cval->channels = 1;
72 cval->control = control;
73 cval->cmask = cmask;
74 cval->idx_off = idx_off;
75
76 /* get_min_max() is called only for integer volumes later,
77 * so provide a short-cut for booleans */
78 cval->min = 0;
79 cval->max = 1;
80 cval->res = 0;
81 cval->dBmin = 0;
82 cval->dBmax = 0;
83
84 /* Create control */
85 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
86 if (!kctl) {
87 kfree(cval);
88 return -ENOMEM;
89 }
90
91 /* Set name */
92 snprintf(kctl->id.name, sizeof(kctl->id.name), name);
93 kctl->private_free = snd_usb_mixer_elem_free;
94
95 /* set TLV */
96 if (tlv_callback) {
97 kctl->tlv.c = tlv_callback;
98 kctl->vd[0].access |=
99 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
100 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
101 }
102 /* Add control to mixer */
103 return snd_usb_mixer_add_control(&cval->head, kctl);
104}
105
106static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
107 unsigned int unitid,
108 unsigned int control,
109 unsigned int cmask,
110 int val_type,
111 const char *name,
112 snd_kcontrol_tlv_rw_t *tlv_callback)
113{
114 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
115 val_type, 0 /* Offset */, name, tlv_callback);
116}
117
118/*
119 * Create a set of standard UAC controls from a table
120 */
121static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
122 struct std_mono_table *t)
123{
124 int err;
125
126 while (t->name != NULL) {
127 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
128 t->cmask, t->val_type, t->name, t->tlv_callback);
129 if (err < 0)
130 return err;
131 t++;
132 }
133
134 return 0;
135}
136
137static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer,
138 int id,
139 usb_mixer_elem_resume_func_t resume,
140 const struct snd_kcontrol_new *knew,
141 struct usb_mixer_elem_list **listp)
142{
143 struct usb_mixer_elem_list *list;
144 struct snd_kcontrol *kctl;
145
146 list = kzalloc(sizeof(*list), GFP_KERNEL);
147 if (!list)
148 return -ENOMEM;
149 if (listp)
150 *listp = list;
151 list->mixer = mixer;
152 list->id = id;
153 list->resume = resume;
154 kctl = snd_ctl_new1(knew, list);
155 if (!kctl) {
156 kfree(list);
157 return -ENOMEM;
158 }
159 kctl->private_free = snd_usb_mixer_elem_free;
160 return snd_usb_mixer_add_control(list, kctl);
161}
162
163/*
164 * Sound Blaster remote control configuration
165 *
166 * format of remote control data:
167 * Extigy: xx 00
168 * Audigy 2 NX: 06 80 xx 00 00 00
169 * Live! 24-bit: 06 80 xx yy 22 83
170 */
171static const struct rc_config {
172 u32 usb_id;
173 u8 offset;
174 u8 length;
175 u8 packet_length;
176 u8 min_packet_length; /* minimum accepted length of the URB result */
177 u8 mute_mixer_id;
178 u32 mute_code;
179} rc_configs[] = {
180 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
181 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
182 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
183 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
184 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
185 { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
186 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
187};
188
189static void snd_usb_soundblaster_remote_complete(struct urb *urb)
190{
191 struct usb_mixer_interface *mixer = urb->context;
192 const struct rc_config *rc = mixer->rc_cfg;
193 u32 code;
194
195 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
196 return;
197
198 code = mixer->rc_buffer[rc->offset];
199 if (rc->length == 2)
200 code |= mixer->rc_buffer[rc->offset + 1] << 8;
201
202 /* the Mute button actually changes the mixer control */
203 if (code == rc->mute_code)
204 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
205 mixer->rc_code = code;
206 wmb();
207 wake_up(&mixer->rc_waitq);
208}
209
210static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
211 long count, loff_t *offset)
212{
213 struct usb_mixer_interface *mixer = hw->private_data;
214 int err;
215 u32 rc_code;
216
217 if (count != 1 && count != 4)
218 return -EINVAL;
219 err = wait_event_interruptible(mixer->rc_waitq,
220 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
221 if (err == 0) {
222 if (count == 1)
223 err = put_user(rc_code, buf);
224 else
225 err = put_user(rc_code, (u32 __user *)buf);
226 }
227 return err < 0 ? err : count;
228}
229
230static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
231 poll_table *wait)
232{
233 struct usb_mixer_interface *mixer = hw->private_data;
234
235 poll_wait(file, &mixer->rc_waitq, wait);
236 return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0;
237}
238
239static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
240{
241 struct snd_hwdep *hwdep;
242 int err, len, i;
243
244 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
245 if (rc_configs[i].usb_id == mixer->chip->usb_id)
246 break;
247 if (i >= ARRAY_SIZE(rc_configs))
248 return 0;
249 mixer->rc_cfg = &rc_configs[i];
250
251 len = mixer->rc_cfg->packet_length;
252
253 init_waitqueue_head(&mixer->rc_waitq);
254 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
255 if (err < 0)
256 return err;
257 snprintf(hwdep->name, sizeof(hwdep->name),
258 "%s remote control", mixer->chip->card->shortname);
259 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
260 hwdep->private_data = mixer;
261 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
262 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
263 hwdep->exclusive = 1;
264
265 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
266 if (!mixer->rc_urb)
267 return -ENOMEM;
268 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
269 if (!mixer->rc_setup_packet) {
270 usb_free_urb(mixer->rc_urb);
271 mixer->rc_urb = NULL;
272 return -ENOMEM;
273 }
274 mixer->rc_setup_packet->bRequestType =
275 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
276 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
277 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
278 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
279 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
280 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
281 usb_rcvctrlpipe(mixer->chip->dev, 0),
282 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
283 snd_usb_soundblaster_remote_complete, mixer);
284 return 0;
285}
286
287#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
288
289static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
290{
291 ucontrol->value.integer.value[0] = kcontrol->private_value >> 8;
292 return 0;
293}
294
295static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer,
296 int value, int index)
297{
298 struct snd_usb_audio *chip = mixer->chip;
299 int err;
300
301 err = snd_usb_lock_shutdown(chip);
302 if (err < 0)
303 return err;
304
305 if (chip->usb_id == USB_ID(0x041e, 0x3042))
306 err = snd_usb_ctl_msg(chip->dev,
307 usb_sndctrlpipe(chip->dev, 0), 0x24,
308 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
309 !value, 0, NULL, 0);
310 /* USB X-Fi S51 Pro */
311 if (chip->usb_id == USB_ID(0x041e, 0x30df))
312 err = snd_usb_ctl_msg(chip->dev,
313 usb_sndctrlpipe(chip->dev, 0), 0x24,
314 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
315 !value, 0, NULL, 0);
316 else
317 err = snd_usb_ctl_msg(chip->dev,
318 usb_sndctrlpipe(chip->dev, 0), 0x24,
319 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
320 value, index + 2, NULL, 0);
321 snd_usb_unlock_shutdown(chip);
322 return err;
323}
324
325static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol,
326 struct snd_ctl_elem_value *ucontrol)
327{
328 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
329 struct usb_mixer_interface *mixer = list->mixer;
330 int index = kcontrol->private_value & 0xff;
331 unsigned int value = ucontrol->value.integer.value[0];
332 int old_value = kcontrol->private_value >> 8;
333 int err;
334
335 if (value > 1)
336 return -EINVAL;
337 if (value == old_value)
338 return 0;
339 kcontrol->private_value = (value << 8) | index;
340 err = snd_audigy2nx_led_update(mixer, value, index);
341 return err < 0 ? err : 1;
342}
343
344static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list)
345{
346 int priv_value = list->kctl->private_value;
347
348 return snd_audigy2nx_led_update(list->mixer, priv_value >> 8,
349 priv_value & 0xff);
350}
351
352/* name and private_value are set dynamically */
353static const struct snd_kcontrol_new snd_audigy2nx_control = {
354 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
355 .info = snd_audigy2nx_led_info,
356 .get = snd_audigy2nx_led_get,
357 .put = snd_audigy2nx_led_put,
358};
359
360static const char * const snd_audigy2nx_led_names[] = {
361 "CMSS LED Switch",
362 "Power LED Switch",
363 "Dolby Digital LED Switch",
364};
365
366static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
367{
368 int i, err;
369
370 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) {
371 struct snd_kcontrol_new knew;
372
373 /* USB X-Fi S51 doesn't have a CMSS LED */
374 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
375 continue;
376 /* USB X-Fi S51 Pro doesn't have one either */
377 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
378 continue;
379 if (i > 1 && /* Live24ext has 2 LEDs only */
380 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
381 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
382 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
383 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
384 break;
385
386 knew = snd_audigy2nx_control;
387 knew.name = snd_audigy2nx_led_names[i];
388 knew.private_value = (1 << 8) | i; /* LED on as default */
389 err = add_single_ctl_with_resume(mixer, 0,
390 snd_audigy2nx_led_resume,
391 &knew, NULL);
392 if (err < 0)
393 return err;
394 }
395 return 0;
396}
397
398static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
399 struct snd_info_buffer *buffer)
400{
401 static const struct sb_jack {
402 int unitid;
403 const char *name;
404 } jacks_audigy2nx[] = {
405 {4, "dig in "},
406 {7, "line in"},
407 {19, "spk out"},
408 {20, "hph out"},
409 {-1, NULL}
410 }, jacks_live24ext[] = {
411 {4, "line in"}, /* &1=Line, &2=Mic*/
412 {3, "hph out"}, /* headphones */
413 {0, "RC "}, /* last command, 6 bytes see rc_config above */
414 {-1, NULL}
415 };
416 const struct sb_jack *jacks;
417 struct usb_mixer_interface *mixer = entry->private_data;
418 int i, err;
419 u8 buf[3];
420
421 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
422 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
423 jacks = jacks_audigy2nx;
424 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
425 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
426 jacks = jacks_live24ext;
427 else
428 return;
429
430 for (i = 0; jacks[i].name; ++i) {
431 snd_iprintf(buffer, "%s: ", jacks[i].name);
432 err = snd_usb_lock_shutdown(mixer->chip);
433 if (err < 0)
434 return;
435 err = snd_usb_ctl_msg(mixer->chip->dev,
436 usb_rcvctrlpipe(mixer->chip->dev, 0),
437 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
438 USB_RECIP_INTERFACE, 0,
439 jacks[i].unitid << 8, buf, 3);
440 snd_usb_unlock_shutdown(mixer->chip);
441 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
442 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
443 else
444 snd_iprintf(buffer, "?\n");
445 }
446}
447
448/* EMU0204 */
449static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
450 struct snd_ctl_elem_info *uinfo)
451{
452 static const char * const texts[2] = {"1/2", "3/4"};
453
454 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
455}
456
457static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
458 struct snd_ctl_elem_value *ucontrol)
459{
460 ucontrol->value.enumerated.item[0] = kcontrol->private_value;
461 return 0;
462}
463
464static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer,
465 int value)
466{
467 struct snd_usb_audio *chip = mixer->chip;
468 int err;
469 unsigned char buf[2];
470
471 err = snd_usb_lock_shutdown(chip);
472 if (err < 0)
473 return err;
474
475 buf[0] = 0x01;
476 buf[1] = value ? 0x02 : 0x01;
477 err = snd_usb_ctl_msg(chip->dev,
478 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
479 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
480 0x0400, 0x0e00, buf, 2);
481 snd_usb_unlock_shutdown(chip);
482 return err;
483}
484
485static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
486 struct snd_ctl_elem_value *ucontrol)
487{
488 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
489 struct usb_mixer_interface *mixer = list->mixer;
490 unsigned int value = ucontrol->value.enumerated.item[0];
491 int err;
492
493 if (value > 1)
494 return -EINVAL;
495
496 if (value == kcontrol->private_value)
497 return 0;
498
499 kcontrol->private_value = value;
500 err = snd_emu0204_ch_switch_update(mixer, value);
501 return err < 0 ? err : 1;
502}
503
504static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list)
505{
506 return snd_emu0204_ch_switch_update(list->mixer,
507 list->kctl->private_value);
508}
509
510static struct snd_kcontrol_new snd_emu0204_control = {
511 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
512 .name = "Front Jack Channels",
513 .info = snd_emu0204_ch_switch_info,
514 .get = snd_emu0204_ch_switch_get,
515 .put = snd_emu0204_ch_switch_put,
516 .private_value = 0,
517};
518
519static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
520{
521 return add_single_ctl_with_resume(mixer, 0,
522 snd_emu0204_ch_switch_resume,
523 &snd_emu0204_control, NULL);
524}
525
526/* ASUS Xonar U1 / U3 controls */
527
528static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
529 struct snd_ctl_elem_value *ucontrol)
530{
531 ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02);
532 return 0;
533}
534
535static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer,
536 unsigned char status)
537{
538 struct snd_usb_audio *chip = mixer->chip;
539 int err;
540
541 err = snd_usb_lock_shutdown(chip);
542 if (err < 0)
543 return err;
544 err = snd_usb_ctl_msg(chip->dev,
545 usb_sndctrlpipe(chip->dev, 0), 0x08,
546 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
547 50, 0, &status, 1);
548 snd_usb_unlock_shutdown(chip);
549 return err;
550}
551
552static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
553 struct snd_ctl_elem_value *ucontrol)
554{
555 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
556 u8 old_status, new_status;
557 int err;
558
559 old_status = kcontrol->private_value;
560 if (ucontrol->value.integer.value[0])
561 new_status = old_status | 0x02;
562 else
563 new_status = old_status & ~0x02;
564 if (new_status == old_status)
565 return 0;
566
567 kcontrol->private_value = new_status;
568 err = snd_xonar_u1_switch_update(list->mixer, new_status);
569 return err < 0 ? err : 1;
570}
571
572static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list)
573{
574 return snd_xonar_u1_switch_update(list->mixer,
575 list->kctl->private_value);
576}
577
578static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
579 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
580 .name = "Digital Playback Switch",
581 .info = snd_ctl_boolean_mono_info,
582 .get = snd_xonar_u1_switch_get,
583 .put = snd_xonar_u1_switch_put,
584 .private_value = 0x05,
585};
586
587static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
588{
589 return add_single_ctl_with_resume(mixer, 0,
590 snd_xonar_u1_switch_resume,
591 &snd_xonar_u1_output_switch, NULL);
592}
593
594/* Digidesign Mbox 1 clock source switch (internal/spdif) */
595
596static int snd_mbox1_switch_get(struct snd_kcontrol *kctl,
597 struct snd_ctl_elem_value *ucontrol)
598{
599 ucontrol->value.enumerated.item[0] = kctl->private_value;
600 return 0;
601}
602
603static int snd_mbox1_switch_update(struct usb_mixer_interface *mixer, int val)
604{
605 struct snd_usb_audio *chip = mixer->chip;
606 int err;
607 unsigned char buff[3];
608
609 err = snd_usb_lock_shutdown(chip);
610 if (err < 0)
611 return err;
612
613 /* Prepare for magic command to toggle clock source */
614 err = snd_usb_ctl_msg(chip->dev,
615 usb_rcvctrlpipe(chip->dev, 0), 0x81,
616 USB_DIR_IN |
617 USB_TYPE_CLASS |
618 USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1);
619 if (err < 0)
620 goto err;
621 err = snd_usb_ctl_msg(chip->dev,
622 usb_rcvctrlpipe(chip->dev, 0), 0x81,
623 USB_DIR_IN |
624 USB_TYPE_CLASS |
625 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
626 if (err < 0)
627 goto err;
628
629 /* 2 possibilities: Internal -> send sample rate
630 * S/PDIF sync -> send zeroes
631 * NB: Sample rate locked to 48kHz on purpose to
632 * prevent user from resetting the sample rate
633 * while S/PDIF sync is enabled and confusing
634 * this configuration.
635 */
636 if (val == 0) {
637 buff[0] = 0x80;
638 buff[1] = 0xbb;
639 buff[2] = 0x00;
640 } else {
641 buff[0] = buff[1] = buff[2] = 0x00;
642 }
643
644 /* Send the magic command to toggle the clock source */
645 err = snd_usb_ctl_msg(chip->dev,
646 usb_sndctrlpipe(chip->dev, 0), 0x1,
647 USB_TYPE_CLASS |
648 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
649 if (err < 0)
650 goto err;
651 err = snd_usb_ctl_msg(chip->dev,
652 usb_rcvctrlpipe(chip->dev, 0), 0x81,
653 USB_DIR_IN |
654 USB_TYPE_CLASS |
655 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
656 if (err < 0)
657 goto err;
658 err = snd_usb_ctl_msg(chip->dev,
659 usb_rcvctrlpipe(chip->dev, 0), 0x81,
660 USB_DIR_IN |
661 USB_TYPE_CLASS |
662 USB_RECIP_ENDPOINT, 0x100, 0x2, buff, 3);
663 if (err < 0)
664 goto err;
665
666err:
667 snd_usb_unlock_shutdown(chip);
668 return err;
669}
670
671static int snd_mbox1_switch_put(struct snd_kcontrol *kctl,
672 struct snd_ctl_elem_value *ucontrol)
673{
674 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
675 struct usb_mixer_interface *mixer = list->mixer;
676 int err;
677 bool cur_val, new_val;
678
679 cur_val = kctl->private_value;
680 new_val = ucontrol->value.enumerated.item[0];
681 if (cur_val == new_val)
682 return 0;
683
684 kctl->private_value = new_val;
685 err = snd_mbox1_switch_update(mixer, new_val);
686 return err < 0 ? err : 1;
687}
688
689static int snd_mbox1_switch_info(struct snd_kcontrol *kcontrol,
690 struct snd_ctl_elem_info *uinfo)
691{
692 static const char *const texts[2] = {
693 "Internal",
694 "S/PDIF"
695 };
696
697 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
698}
699
700static int snd_mbox1_switch_resume(struct usb_mixer_elem_list *list)
701{
702 return snd_mbox1_switch_update(list->mixer, list->kctl->private_value);
703}
704
705static struct snd_kcontrol_new snd_mbox1_switch = {
706 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
707 .name = "Clock Source",
708 .index = 0,
709 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
710 .info = snd_mbox1_switch_info,
711 .get = snd_mbox1_switch_get,
712 .put = snd_mbox1_switch_put,
713 .private_value = 0
714};
715
716static int snd_mbox1_create_sync_switch(struct usb_mixer_interface *mixer)
717{
718 return add_single_ctl_with_resume(mixer, 0,
719 snd_mbox1_switch_resume,
720 &snd_mbox1_switch, NULL);
721}
722
723/* Native Instruments device quirks */
724
725#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
726
727static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
728 struct snd_kcontrol *kctl)
729{
730 struct usb_device *dev = mixer->chip->dev;
731 unsigned int pval = kctl->private_value;
732 u8 value;
733 int err;
734
735 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
736 (pval >> 16) & 0xff,
737 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
738 0, pval & 0xffff, &value, 1);
739 if (err < 0) {
740 dev_err(&dev->dev,
741 "unable to issue vendor read request (ret = %d)", err);
742 return err;
743 }
744
745 kctl->private_value |= ((unsigned int)value << 24);
746 return 0;
747}
748
749static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
750 struct snd_ctl_elem_value *ucontrol)
751{
752 ucontrol->value.integer.value[0] = kcontrol->private_value >> 24;
753 return 0;
754}
755
756static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list)
757{
758 struct snd_usb_audio *chip = list->mixer->chip;
759 unsigned int pval = list->kctl->private_value;
760 int err;
761
762 err = snd_usb_lock_shutdown(chip);
763 if (err < 0)
764 return err;
765 err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
766 (pval >> 16) & 0xff,
767 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
768 pval >> 24, pval & 0xffff, NULL, 0, 1000);
769 snd_usb_unlock_shutdown(chip);
770 return err;
771}
772
773static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
774 struct snd_ctl_elem_value *ucontrol)
775{
776 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
777 u8 oldval = (kcontrol->private_value >> 24) & 0xff;
778 u8 newval = ucontrol->value.integer.value[0];
779 int err;
780
781 if (oldval == newval)
782 return 0;
783
784 kcontrol->private_value &= ~(0xff << 24);
785 kcontrol->private_value |= (unsigned int)newval << 24;
786 err = snd_ni_update_cur_val(list);
787 return err < 0 ? err : 1;
788}
789
790static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
791 {
792 .name = "Direct Thru Channel A",
793 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
794 },
795 {
796 .name = "Direct Thru Channel B",
797 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
798 },
799 {
800 .name = "Phono Input Channel A",
801 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
802 },
803 {
804 .name = "Phono Input Channel B",
805 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
806 },
807};
808
809static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
810 {
811 .name = "Direct Thru Channel A",
812 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
813 },
814 {
815 .name = "Direct Thru Channel B",
816 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
817 },
818 {
819 .name = "Direct Thru Channel C",
820 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
821 },
822 {
823 .name = "Direct Thru Channel D",
824 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
825 },
826 {
827 .name = "Phono Input Channel A",
828 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
829 },
830 {
831 .name = "Phono Input Channel B",
832 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
833 },
834 {
835 .name = "Phono Input Channel C",
836 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
837 },
838 {
839 .name = "Phono Input Channel D",
840 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
841 },
842};
843
844static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
845 const struct snd_kcontrol_new *kc,
846 unsigned int count)
847{
848 int i, err = 0;
849 struct snd_kcontrol_new template = {
850 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
851 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
852 .get = snd_nativeinstruments_control_get,
853 .put = snd_nativeinstruments_control_put,
854 .info = snd_ctl_boolean_mono_info,
855 };
856
857 for (i = 0; i < count; i++) {
858 struct usb_mixer_elem_list *list;
859
860 template.name = kc[i].name;
861 template.private_value = kc[i].private_value;
862
863 err = add_single_ctl_with_resume(mixer, 0,
864 snd_ni_update_cur_val,
865 &template, &list);
866 if (err < 0)
867 break;
868 snd_ni_control_init_val(mixer, list->kctl);
869 }
870
871 return err;
872}
873
874/* M-Audio FastTrack Ultra quirks */
875/* FTU Effect switch (also used by C400/C600) */
876static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
877 struct snd_ctl_elem_info *uinfo)
878{
879 static const char *const texts[8] = {
880 "Room 1", "Room 2", "Room 3", "Hall 1",
881 "Hall 2", "Plate", "Delay", "Echo"
882 };
883
884 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
885}
886
887static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
888 struct snd_kcontrol *kctl)
889{
890 struct usb_device *dev = mixer->chip->dev;
891 unsigned int pval = kctl->private_value;
892 int err;
893 unsigned char value[2];
894
895 value[0] = 0x00;
896 value[1] = 0x00;
897
898 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
899 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
900 pval & 0xff00,
901 snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8),
902 value, 2);
903 if (err < 0)
904 return err;
905
906 kctl->private_value |= (unsigned int)value[0] << 24;
907 return 0;
908}
909
910static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
911 struct snd_ctl_elem_value *ucontrol)
912{
913 ucontrol->value.enumerated.item[0] = kctl->private_value >> 24;
914 return 0;
915}
916
917static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list)
918{
919 struct snd_usb_audio *chip = list->mixer->chip;
920 unsigned int pval = list->kctl->private_value;
921 unsigned char value[2];
922 int err;
923
924 value[0] = pval >> 24;
925 value[1] = 0;
926
927 err = snd_usb_lock_shutdown(chip);
928 if (err < 0)
929 return err;
930 err = snd_usb_ctl_msg(chip->dev,
931 usb_sndctrlpipe(chip->dev, 0),
932 UAC_SET_CUR,
933 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
934 pval & 0xff00,
935 snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8),
936 value, 2);
937 snd_usb_unlock_shutdown(chip);
938 return err;
939}
940
941static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
942 struct snd_ctl_elem_value *ucontrol)
943{
944 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
945 unsigned int pval = list->kctl->private_value;
946 int cur_val, err, new_val;
947
948 cur_val = pval >> 24;
949 new_val = ucontrol->value.enumerated.item[0];
950 if (cur_val == new_val)
951 return 0;
952
953 kctl->private_value &= ~(0xff << 24);
954 kctl->private_value |= new_val << 24;
955 err = snd_ftu_eff_switch_update(list);
956 return err < 0 ? err : 1;
957}
958
959static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
960 int validx, int bUnitID)
961{
962 static struct snd_kcontrol_new template = {
963 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
964 .name = "Effect Program Switch",
965 .index = 0,
966 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
967 .info = snd_ftu_eff_switch_info,
968 .get = snd_ftu_eff_switch_get,
969 .put = snd_ftu_eff_switch_put
970 };
971 struct usb_mixer_elem_list *list;
972 int err;
973
974 err = add_single_ctl_with_resume(mixer, bUnitID,
975 snd_ftu_eff_switch_update,
976 &template, &list);
977 if (err < 0)
978 return err;
979 list->kctl->private_value = (validx << 8) | bUnitID;
980 snd_ftu_eff_switch_init(mixer, list->kctl);
981 return 0;
982}
983
984/* Create volume controls for FTU devices*/
985static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
986{
987 char name[64];
988 unsigned int control, cmask;
989 int in, out, err;
990
991 const unsigned int id = 5;
992 const int val_type = USB_MIXER_S16;
993
994 for (out = 0; out < 8; out++) {
995 control = out + 1;
996 for (in = 0; in < 8; in++) {
997 cmask = 1 << in;
998 snprintf(name, sizeof(name),
999 "AIn%d - Out%d Capture Volume",
1000 in + 1, out + 1);
1001 err = snd_create_std_mono_ctl(mixer, id, control,
1002 cmask, val_type, name,
1003 &snd_usb_mixer_vol_tlv);
1004 if (err < 0)
1005 return err;
1006 }
1007 for (in = 8; in < 16; in++) {
1008 cmask = 1 << in;
1009 snprintf(name, sizeof(name),
1010 "DIn%d - Out%d Playback Volume",
1011 in - 7, out + 1);
1012 err = snd_create_std_mono_ctl(mixer, id, control,
1013 cmask, val_type, name,
1014 &snd_usb_mixer_vol_tlv);
1015 if (err < 0)
1016 return err;
1017 }
1018 }
1019
1020 return 0;
1021}
1022
1023/* This control needs a volume quirk, see mixer.c */
1024static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1025{
1026 static const char name[] = "Effect Volume";
1027 const unsigned int id = 6;
1028 const int val_type = USB_MIXER_U8;
1029 const unsigned int control = 2;
1030 const unsigned int cmask = 0;
1031
1032 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1033 name, snd_usb_mixer_vol_tlv);
1034}
1035
1036/* This control needs a volume quirk, see mixer.c */
1037static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1038{
1039 static const char name[] = "Effect Duration";
1040 const unsigned int id = 6;
1041 const int val_type = USB_MIXER_S16;
1042 const unsigned int control = 3;
1043 const unsigned int cmask = 0;
1044
1045 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1046 name, snd_usb_mixer_vol_tlv);
1047}
1048
1049/* This control needs a volume quirk, see mixer.c */
1050static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1051{
1052 static const char name[] = "Effect Feedback Volume";
1053 const unsigned int id = 6;
1054 const int val_type = USB_MIXER_U8;
1055 const unsigned int control = 4;
1056 const unsigned int cmask = 0;
1057
1058 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1059 name, NULL);
1060}
1061
1062static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1063{
1064 unsigned int cmask;
1065 int err, ch;
1066 char name[48];
1067
1068 const unsigned int id = 7;
1069 const int val_type = USB_MIXER_S16;
1070 const unsigned int control = 7;
1071
1072 for (ch = 0; ch < 4; ++ch) {
1073 cmask = 1 << ch;
1074 snprintf(name, sizeof(name),
1075 "Effect Return %d Volume", ch + 1);
1076 err = snd_create_std_mono_ctl(mixer, id, control,
1077 cmask, val_type, name,
1078 snd_usb_mixer_vol_tlv);
1079 if (err < 0)
1080 return err;
1081 }
1082
1083 return 0;
1084}
1085
1086static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1087{
1088 unsigned int cmask;
1089 int err, ch;
1090 char name[48];
1091
1092 const unsigned int id = 5;
1093 const int val_type = USB_MIXER_S16;
1094 const unsigned int control = 9;
1095
1096 for (ch = 0; ch < 8; ++ch) {
1097 cmask = 1 << ch;
1098 snprintf(name, sizeof(name),
1099 "Effect Send AIn%d Volume", ch + 1);
1100 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1101 val_type, name,
1102 snd_usb_mixer_vol_tlv);
1103 if (err < 0)
1104 return err;
1105 }
1106 for (ch = 8; ch < 16; ++ch) {
1107 cmask = 1 << ch;
1108 snprintf(name, sizeof(name),
1109 "Effect Send DIn%d Volume", ch - 7);
1110 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1111 val_type, name,
1112 snd_usb_mixer_vol_tlv);
1113 if (err < 0)
1114 return err;
1115 }
1116 return 0;
1117}
1118
1119static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1120{
1121 int err;
1122
1123 err = snd_ftu_create_volume_ctls(mixer);
1124 if (err < 0)
1125 return err;
1126
1127 err = snd_ftu_create_effect_switch(mixer, 1, 6);
1128 if (err < 0)
1129 return err;
1130
1131 err = snd_ftu_create_effect_volume_ctl(mixer);
1132 if (err < 0)
1133 return err;
1134
1135 err = snd_ftu_create_effect_duration_ctl(mixer);
1136 if (err < 0)
1137 return err;
1138
1139 err = snd_ftu_create_effect_feedback_ctl(mixer);
1140 if (err < 0)
1141 return err;
1142
1143 err = snd_ftu_create_effect_return_ctls(mixer);
1144 if (err < 0)
1145 return err;
1146
1147 err = snd_ftu_create_effect_send_ctls(mixer);
1148 if (err < 0)
1149 return err;
1150
1151 return 0;
1152}
1153
1154void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1155 unsigned char samplerate_id)
1156{
1157 struct usb_mixer_interface *mixer;
1158 struct usb_mixer_elem_info *cval;
1159 int unitid = 12; /* SampleRate ExtensionUnit ID */
1160
1161 list_for_each_entry(mixer, &chip->mixer_list, list) {
1162 if (mixer->id_elems[unitid]) {
1163 cval = mixer_elem_list_to_info(mixer->id_elems[unitid]);
1164 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1165 cval->control << 8,
1166 samplerate_id);
1167 snd_usb_mixer_notify_id(mixer, unitid);
1168 break;
1169 }
1170 }
1171}
1172
1173/* M-Audio Fast Track C400/C600 */
1174/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1175static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1176{
1177 char name[64];
1178 unsigned int cmask, offset;
1179 int out, chan, err;
1180 int num_outs = 0;
1181 int num_ins = 0;
1182
1183 const unsigned int id = 0x40;
1184 const int val_type = USB_MIXER_S16;
1185 const int control = 1;
1186
1187 switch (mixer->chip->usb_id) {
1188 case USB_ID(0x0763, 0x2030):
1189 num_outs = 6;
1190 num_ins = 4;
1191 break;
1192 case USB_ID(0x0763, 0x2031):
1193 num_outs = 8;
1194 num_ins = 6;
1195 break;
1196 }
1197
1198 for (chan = 0; chan < num_outs + num_ins; chan++) {
1199 for (out = 0; out < num_outs; out++) {
1200 if (chan < num_outs) {
1201 snprintf(name, sizeof(name),
1202 "PCM%d-Out%d Playback Volume",
1203 chan + 1, out + 1);
1204 } else {
1205 snprintf(name, sizeof(name),
1206 "In%d-Out%d Playback Volume",
1207 chan - num_outs + 1, out + 1);
1208 }
1209
1210 cmask = (out == 0) ? 0 : 1 << (out - 1);
1211 offset = chan * num_outs;
1212 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1213 cmask, val_type, offset, name,
1214 &snd_usb_mixer_vol_tlv);
1215 if (err < 0)
1216 return err;
1217 }
1218 }
1219
1220 return 0;
1221}
1222
1223/* This control needs a volume quirk, see mixer.c */
1224static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1225{
1226 static const char name[] = "Effect Volume";
1227 const unsigned int id = 0x43;
1228 const int val_type = USB_MIXER_U8;
1229 const unsigned int control = 3;
1230 const unsigned int cmask = 0;
1231
1232 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1233 name, snd_usb_mixer_vol_tlv);
1234}
1235
1236/* This control needs a volume quirk, see mixer.c */
1237static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1238{
1239 static const char name[] = "Effect Duration";
1240 const unsigned int id = 0x43;
1241 const int val_type = USB_MIXER_S16;
1242 const unsigned int control = 4;
1243 const unsigned int cmask = 0;
1244
1245 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1246 name, snd_usb_mixer_vol_tlv);
1247}
1248
1249/* This control needs a volume quirk, see mixer.c */
1250static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1251{
1252 static const char name[] = "Effect Feedback Volume";
1253 const unsigned int id = 0x43;
1254 const int val_type = USB_MIXER_U8;
1255 const unsigned int control = 5;
1256 const unsigned int cmask = 0;
1257
1258 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1259 name, NULL);
1260}
1261
1262static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1263{
1264 char name[64];
1265 unsigned int cmask;
1266 int chan, err;
1267 int num_outs = 0;
1268 int num_ins = 0;
1269
1270 const unsigned int id = 0x42;
1271 const int val_type = USB_MIXER_S16;
1272 const int control = 1;
1273
1274 switch (mixer->chip->usb_id) {
1275 case USB_ID(0x0763, 0x2030):
1276 num_outs = 6;
1277 num_ins = 4;
1278 break;
1279 case USB_ID(0x0763, 0x2031):
1280 num_outs = 8;
1281 num_ins = 6;
1282 break;
1283 }
1284
1285 for (chan = 0; chan < num_outs + num_ins; chan++) {
1286 if (chan < num_outs) {
1287 snprintf(name, sizeof(name),
1288 "Effect Send DOut%d",
1289 chan + 1);
1290 } else {
1291 snprintf(name, sizeof(name),
1292 "Effect Send AIn%d",
1293 chan - num_outs + 1);
1294 }
1295
1296 cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1297 err = snd_create_std_mono_ctl(mixer, id, control,
1298 cmask, val_type, name,
1299 &snd_usb_mixer_vol_tlv);
1300 if (err < 0)
1301 return err;
1302 }
1303
1304 return 0;
1305}
1306
1307static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1308{
1309 char name[64];
1310 unsigned int cmask;
1311 int chan, err;
1312 int num_outs = 0;
1313 int offset = 0;
1314
1315 const unsigned int id = 0x40;
1316 const int val_type = USB_MIXER_S16;
1317 const int control = 1;
1318
1319 switch (mixer->chip->usb_id) {
1320 case USB_ID(0x0763, 0x2030):
1321 num_outs = 6;
1322 offset = 0x3c;
1323 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1324 break;
1325 case USB_ID(0x0763, 0x2031):
1326 num_outs = 8;
1327 offset = 0x70;
1328 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1329 break;
1330 }
1331
1332 for (chan = 0; chan < num_outs; chan++) {
1333 snprintf(name, sizeof(name),
1334 "Effect Return %d",
1335 chan + 1);
1336
1337 cmask = (chan == 0) ? 0 :
1338 1 << (chan + (chan % 2) * num_outs - 1);
1339 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1340 cmask, val_type, offset, name,
1341 &snd_usb_mixer_vol_tlv);
1342 if (err < 0)
1343 return err;
1344 }
1345
1346 return 0;
1347}
1348
1349static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1350{
1351 int err;
1352
1353 err = snd_c400_create_vol_ctls(mixer);
1354 if (err < 0)
1355 return err;
1356
1357 err = snd_c400_create_effect_vol_ctls(mixer);
1358 if (err < 0)
1359 return err;
1360
1361 err = snd_c400_create_effect_ret_vol_ctls(mixer);
1362 if (err < 0)
1363 return err;
1364
1365 err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1366 if (err < 0)
1367 return err;
1368
1369 err = snd_c400_create_effect_volume_ctl(mixer);
1370 if (err < 0)
1371 return err;
1372
1373 err = snd_c400_create_effect_duration_ctl(mixer);
1374 if (err < 0)
1375 return err;
1376
1377 err = snd_c400_create_effect_feedback_ctl(mixer);
1378 if (err < 0)
1379 return err;
1380
1381 return 0;
1382}
1383
1384/*
1385 * The mixer units for Ebox-44 are corrupt, and even where they
1386 * are valid they presents mono controls as L and R channels of
1387 * stereo. So we provide a good mixer here.
1388 */
1389static struct std_mono_table ebox44_table[] = {
1390 {
1391 .unitid = 4,
1392 .control = 1,
1393 .cmask = 0x0,
1394 .val_type = USB_MIXER_INV_BOOLEAN,
1395 .name = "Headphone Playback Switch"
1396 },
1397 {
1398 .unitid = 4,
1399 .control = 2,
1400 .cmask = 0x1,
1401 .val_type = USB_MIXER_S16,
1402 .name = "Headphone A Mix Playback Volume"
1403 },
1404 {
1405 .unitid = 4,
1406 .control = 2,
1407 .cmask = 0x2,
1408 .val_type = USB_MIXER_S16,
1409 .name = "Headphone B Mix Playback Volume"
1410 },
1411
1412 {
1413 .unitid = 7,
1414 .control = 1,
1415 .cmask = 0x0,
1416 .val_type = USB_MIXER_INV_BOOLEAN,
1417 .name = "Output Playback Switch"
1418 },
1419 {
1420 .unitid = 7,
1421 .control = 2,
1422 .cmask = 0x1,
1423 .val_type = USB_MIXER_S16,
1424 .name = "Output A Playback Volume"
1425 },
1426 {
1427 .unitid = 7,
1428 .control = 2,
1429 .cmask = 0x2,
1430 .val_type = USB_MIXER_S16,
1431 .name = "Output B Playback Volume"
1432 },
1433
1434 {
1435 .unitid = 10,
1436 .control = 1,
1437 .cmask = 0x0,
1438 .val_type = USB_MIXER_INV_BOOLEAN,
1439 .name = "Input Capture Switch"
1440 },
1441 {
1442 .unitid = 10,
1443 .control = 2,
1444 .cmask = 0x1,
1445 .val_type = USB_MIXER_S16,
1446 .name = "Input A Capture Volume"
1447 },
1448 {
1449 .unitid = 10,
1450 .control = 2,
1451 .cmask = 0x2,
1452 .val_type = USB_MIXER_S16,
1453 .name = "Input B Capture Volume"
1454 },
1455
1456 {}
1457};
1458
1459/* Audio Advantage Micro II findings:
1460 *
1461 * Mapping spdif AES bits to vendor register.bit:
1462 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1463 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1464 * AES2: [0 0 0 0 0 0 0 0]
1465 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1466 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1467 *
1468 * power on values:
1469 * r2: 0x10
1470 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1471 * just after it to 0xa0, presumably it disables/mutes some analog
1472 * parts when there is no audio.)
1473 * r9: 0x28
1474 *
1475 * Optical transmitter on/off:
1476 * vendor register.bit: 9.1
1477 * 0 - on (0x28 register value)
1478 * 1 - off (0x2a register value)
1479 *
1480 */
1481static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1482 struct snd_ctl_elem_info *uinfo)
1483{
1484 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1485 uinfo->count = 1;
1486 return 0;
1487}
1488
1489static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1490 struct snd_ctl_elem_value *ucontrol)
1491{
1492 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1493 struct snd_usb_audio *chip = list->mixer->chip;
1494 int err;
1495 struct usb_interface *iface;
1496 struct usb_host_interface *alts;
1497 unsigned int ep;
1498 unsigned char data[3];
1499 int rate;
1500
1501 err = snd_usb_lock_shutdown(chip);
1502 if (err < 0)
1503 return err;
1504
1505 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1506 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1507 ucontrol->value.iec958.status[2] = 0x00;
1508
1509 /* use known values for that card: interface#1 altsetting#1 */
1510 iface = usb_ifnum_to_if(chip->dev, 1);
1511 if (!iface || iface->num_altsetting < 2)
1512 return -EINVAL;
1513 alts = &iface->altsetting[1];
1514 if (get_iface_desc(alts)->bNumEndpoints < 1)
1515 return -EINVAL;
1516 ep = get_endpoint(alts, 0)->bEndpointAddress;
1517
1518 err = snd_usb_ctl_msg(chip->dev,
1519 usb_rcvctrlpipe(chip->dev, 0),
1520 UAC_GET_CUR,
1521 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1522 UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1523 ep,
1524 data,
1525 sizeof(data));
1526 if (err < 0)
1527 goto end;
1528
1529 rate = data[0] | (data[1] << 8) | (data[2] << 16);
1530 ucontrol->value.iec958.status[3] = (rate == 48000) ?
1531 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1532
1533 err = 0;
1534 end:
1535 snd_usb_unlock_shutdown(chip);
1536 return err;
1537}
1538
1539static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list)
1540{
1541 struct snd_usb_audio *chip = list->mixer->chip;
1542 unsigned int pval = list->kctl->private_value;
1543 u8 reg;
1544 int err;
1545
1546 err = snd_usb_lock_shutdown(chip);
1547 if (err < 0)
1548 return err;
1549
1550 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f);
1551 err = snd_usb_ctl_msg(chip->dev,
1552 usb_sndctrlpipe(chip->dev, 0),
1553 UAC_SET_CUR,
1554 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1555 reg,
1556 2,
1557 NULL,
1558 0);
1559 if (err < 0)
1560 goto end;
1561
1562 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20;
1563 reg |= (pval >> 12) & 0x0f;
1564 err = snd_usb_ctl_msg(chip->dev,
1565 usb_sndctrlpipe(chip->dev, 0),
1566 UAC_SET_CUR,
1567 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1568 reg,
1569 3,
1570 NULL,
1571 0);
1572 if (err < 0)
1573 goto end;
1574
1575 end:
1576 snd_usb_unlock_shutdown(chip);
1577 return err;
1578}
1579
1580static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1581 struct snd_ctl_elem_value *ucontrol)
1582{
1583 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1584 unsigned int pval, pval_old;
1585 int err;
1586
1587 pval = pval_old = kcontrol->private_value;
1588 pval &= 0xfffff0f0;
1589 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1590 pval |= (ucontrol->value.iec958.status[0] & 0x0f);
1591
1592 pval &= 0xffff0fff;
1593 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1594
1595 /* The frequency bits in AES3 cannot be set via register access. */
1596
1597 /* Silently ignore any bits from the request that cannot be set. */
1598
1599 if (pval == pval_old)
1600 return 0;
1601
1602 kcontrol->private_value = pval;
1603 err = snd_microii_spdif_default_update(list);
1604 return err < 0 ? err : 1;
1605}
1606
1607static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1608 struct snd_ctl_elem_value *ucontrol)
1609{
1610 ucontrol->value.iec958.status[0] = 0x0f;
1611 ucontrol->value.iec958.status[1] = 0xff;
1612 ucontrol->value.iec958.status[2] = 0x00;
1613 ucontrol->value.iec958.status[3] = 0x00;
1614
1615 return 0;
1616}
1617
1618static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1619 struct snd_ctl_elem_value *ucontrol)
1620{
1621 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1622
1623 return 0;
1624}
1625
1626static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list)
1627{
1628 struct snd_usb_audio *chip = list->mixer->chip;
1629 u8 reg = list->kctl->private_value;
1630 int err;
1631
1632 err = snd_usb_lock_shutdown(chip);
1633 if (err < 0)
1634 return err;
1635
1636 err = snd_usb_ctl_msg(chip->dev,
1637 usb_sndctrlpipe(chip->dev, 0),
1638 UAC_SET_CUR,
1639 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1640 reg,
1641 9,
1642 NULL,
1643 0);
1644
1645 snd_usb_unlock_shutdown(chip);
1646 return err;
1647}
1648
1649static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1650 struct snd_ctl_elem_value *ucontrol)
1651{
1652 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1653 u8 reg;
1654 int err;
1655
1656 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1657 if (reg != list->kctl->private_value)
1658 return 0;
1659
1660 kcontrol->private_value = reg;
1661 err = snd_microii_spdif_switch_update(list);
1662 return err < 0 ? err : 1;
1663}
1664
1665static struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1666 {
1667 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1668 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1669 .info = snd_microii_spdif_info,
1670 .get = snd_microii_spdif_default_get,
1671 .put = snd_microii_spdif_default_put,
1672 .private_value = 0x00000100UL,/* reset value */
1673 },
1674 {
1675 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1676 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1677 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1678 .info = snd_microii_spdif_info,
1679 .get = snd_microii_spdif_mask_get,
1680 },
1681 {
1682 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1683 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1684 .info = snd_ctl_boolean_mono_info,
1685 .get = snd_microii_spdif_switch_get,
1686 .put = snd_microii_spdif_switch_put,
1687 .private_value = 0x00000028UL,/* reset value */
1688 }
1689};
1690
1691static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1692{
1693 int err, i;
1694 static usb_mixer_elem_resume_func_t resume_funcs[] = {
1695 snd_microii_spdif_default_update,
1696 NULL,
1697 snd_microii_spdif_switch_update
1698 };
1699
1700 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1701 err = add_single_ctl_with_resume(mixer, 0,
1702 resume_funcs[i],
1703 &snd_microii_mixer_spdif[i],
1704 NULL);
1705 if (err < 0)
1706 return err;
1707 }
1708
1709 return 0;
1710}
1711
1712/* Creative Sound Blaster E1 */
1713
1714static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol,
1715 struct snd_ctl_elem_value *ucontrol)
1716{
1717 ucontrol->value.integer.value[0] = kcontrol->private_value;
1718 return 0;
1719}
1720
1721static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer,
1722 unsigned char state)
1723{
1724 struct snd_usb_audio *chip = mixer->chip;
1725 int err;
1726 unsigned char buff[2];
1727
1728 buff[0] = 0x02;
1729 buff[1] = state ? 0x02 : 0x00;
1730
1731 err = snd_usb_lock_shutdown(chip);
1732 if (err < 0)
1733 return err;
1734 err = snd_usb_ctl_msg(chip->dev,
1735 usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT,
1736 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
1737 0x0202, 3, buff, 2);
1738 snd_usb_unlock_shutdown(chip);
1739 return err;
1740}
1741
1742static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol,
1743 struct snd_ctl_elem_value *ucontrol)
1744{
1745 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1746 unsigned char value = !!ucontrol->value.integer.value[0];
1747 int err;
1748
1749 if (kcontrol->private_value == value)
1750 return 0;
1751 kcontrol->private_value = value;
1752 err = snd_soundblaster_e1_switch_update(list->mixer, value);
1753 return err < 0 ? err : 1;
1754}
1755
1756static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list)
1757{
1758 return snd_soundblaster_e1_switch_update(list->mixer,
1759 list->kctl->private_value);
1760}
1761
1762static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol,
1763 struct snd_ctl_elem_info *uinfo)
1764{
1765 static const char *const texts[2] = {
1766 "Mic", "Aux"
1767 };
1768
1769 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1770}
1771
1772static struct snd_kcontrol_new snd_soundblaster_e1_input_switch = {
1773 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1774 .name = "Input Source",
1775 .info = snd_soundblaster_e1_switch_info,
1776 .get = snd_soundblaster_e1_switch_get,
1777 .put = snd_soundblaster_e1_switch_put,
1778 .private_value = 0,
1779};
1780
1781static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer)
1782{
1783 return add_single_ctl_with_resume(mixer, 0,
1784 snd_soundblaster_e1_switch_resume,
1785 &snd_soundblaster_e1_input_switch,
1786 NULL);
1787}
1788
1789static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id)
1790{
1791 u16 buf = 0;
1792
1793 snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
1794 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1795 ch, snd_usb_ctrl_intf(chip) | (id << 8),
1796 &buf, 2);
1797}
1798
1799static int dell_dock_mixer_init(struct usb_mixer_interface *mixer)
1800{
1801 /* fix to 0dB playback volumes */
1802 dell_dock_init_vol(mixer->chip, 1, 16);
1803 dell_dock_init_vol(mixer->chip, 2, 16);
1804 dell_dock_init_vol(mixer->chip, 1, 19);
1805 dell_dock_init_vol(mixer->chip, 2, 19);
1806 return 0;
1807}
1808
1809/* RME Class Compliant device quirks */
1810
1811#define SND_RME_GET_STATUS1 23
1812#define SND_RME_GET_CURRENT_FREQ 17
1813#define SND_RME_CLK_SYSTEM_SHIFT 16
1814#define SND_RME_CLK_SYSTEM_MASK 0x1f
1815#define SND_RME_CLK_AES_SHIFT 8
1816#define SND_RME_CLK_SPDIF_SHIFT 12
1817#define SND_RME_CLK_AES_SPDIF_MASK 0xf
1818#define SND_RME_CLK_SYNC_SHIFT 6
1819#define SND_RME_CLK_SYNC_MASK 0x3
1820#define SND_RME_CLK_FREQMUL_SHIFT 18
1821#define SND_RME_CLK_FREQMUL_MASK 0x7
1822#define SND_RME_CLK_SYSTEM(x) \
1823 ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK)
1824#define SND_RME_CLK_AES(x) \
1825 ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1826#define SND_RME_CLK_SPDIF(x) \
1827 ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1828#define SND_RME_CLK_SYNC(x) \
1829 ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK)
1830#define SND_RME_CLK_FREQMUL(x) \
1831 ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK)
1832#define SND_RME_CLK_AES_LOCK 0x1
1833#define SND_RME_CLK_AES_SYNC 0x4
1834#define SND_RME_CLK_SPDIF_LOCK 0x2
1835#define SND_RME_CLK_SPDIF_SYNC 0x8
1836#define SND_RME_SPDIF_IF_SHIFT 4
1837#define SND_RME_SPDIF_FORMAT_SHIFT 5
1838#define SND_RME_BINARY_MASK 0x1
1839#define SND_RME_SPDIF_IF(x) \
1840 ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK)
1841#define SND_RME_SPDIF_FORMAT(x) \
1842 ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK)
1843
1844static const u32 snd_rme_rate_table[] = {
1845 32000, 44100, 48000, 50000,
1846 64000, 88200, 96000, 100000,
1847 128000, 176400, 192000, 200000,
1848 256000, 352800, 384000, 400000,
1849 512000, 705600, 768000, 800000
1850};
1851/* maximum number of items for AES and S/PDIF rates for above table */
1852#define SND_RME_RATE_IDX_AES_SPDIF_NUM 12
1853
1854enum snd_rme_domain {
1855 SND_RME_DOMAIN_SYSTEM,
1856 SND_RME_DOMAIN_AES,
1857 SND_RME_DOMAIN_SPDIF
1858};
1859
1860enum snd_rme_clock_status {
1861 SND_RME_CLOCK_NOLOCK,
1862 SND_RME_CLOCK_LOCK,
1863 SND_RME_CLOCK_SYNC
1864};
1865
1866static int snd_rme_read_value(struct snd_usb_audio *chip,
1867 unsigned int item,
1868 u32 *value)
1869{
1870 struct usb_device *dev = chip->dev;
1871 int err;
1872
1873 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
1874 item,
1875 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1876 0, 0,
1877 value, sizeof(*value));
1878 if (err < 0)
1879 dev_err(&dev->dev,
1880 "unable to issue vendor read request %d (ret = %d)",
1881 item, err);
1882 return err;
1883}
1884
1885static int snd_rme_get_status1(struct snd_kcontrol *kcontrol,
1886 u32 *status1)
1887{
1888 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1889 struct snd_usb_audio *chip = list->mixer->chip;
1890 int err;
1891
1892 err = snd_usb_lock_shutdown(chip);
1893 if (err < 0)
1894 return err;
1895 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1);
1896 snd_usb_unlock_shutdown(chip);
1897 return err;
1898}
1899
1900static int snd_rme_rate_get(struct snd_kcontrol *kcontrol,
1901 struct snd_ctl_elem_value *ucontrol)
1902{
1903 u32 status1;
1904 u32 rate = 0;
1905 int idx;
1906 int err;
1907
1908 err = snd_rme_get_status1(kcontrol, &status1);
1909 if (err < 0)
1910 return err;
1911 switch (kcontrol->private_value) {
1912 case SND_RME_DOMAIN_SYSTEM:
1913 idx = SND_RME_CLK_SYSTEM(status1);
1914 if (idx < ARRAY_SIZE(snd_rme_rate_table))
1915 rate = snd_rme_rate_table[idx];
1916 break;
1917 case SND_RME_DOMAIN_AES:
1918 idx = SND_RME_CLK_AES(status1);
1919 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
1920 rate = snd_rme_rate_table[idx];
1921 break;
1922 case SND_RME_DOMAIN_SPDIF:
1923 idx = SND_RME_CLK_SPDIF(status1);
1924 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
1925 rate = snd_rme_rate_table[idx];
1926 break;
1927 default:
1928 return -EINVAL;
1929 }
1930 ucontrol->value.integer.value[0] = rate;
1931 return 0;
1932}
1933
1934static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol,
1935 struct snd_ctl_elem_value *ucontrol)
1936{
1937 u32 status1;
1938 int idx = SND_RME_CLOCK_NOLOCK;
1939 int err;
1940
1941 err = snd_rme_get_status1(kcontrol, &status1);
1942 if (err < 0)
1943 return err;
1944 switch (kcontrol->private_value) {
1945 case SND_RME_DOMAIN_AES: /* AES */
1946 if (status1 & SND_RME_CLK_AES_SYNC)
1947 idx = SND_RME_CLOCK_SYNC;
1948 else if (status1 & SND_RME_CLK_AES_LOCK)
1949 idx = SND_RME_CLOCK_LOCK;
1950 break;
1951 case SND_RME_DOMAIN_SPDIF: /* SPDIF */
1952 if (status1 & SND_RME_CLK_SPDIF_SYNC)
1953 idx = SND_RME_CLOCK_SYNC;
1954 else if (status1 & SND_RME_CLK_SPDIF_LOCK)
1955 idx = SND_RME_CLOCK_LOCK;
1956 break;
1957 default:
1958 return -EINVAL;
1959 }
1960 ucontrol->value.enumerated.item[0] = idx;
1961 return 0;
1962}
1963
1964static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol,
1965 struct snd_ctl_elem_value *ucontrol)
1966{
1967 u32 status1;
1968 int err;
1969
1970 err = snd_rme_get_status1(kcontrol, &status1);
1971 if (err < 0)
1972 return err;
1973 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1);
1974 return 0;
1975}
1976
1977static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol,
1978 struct snd_ctl_elem_value *ucontrol)
1979{
1980 u32 status1;
1981 int err;
1982
1983 err = snd_rme_get_status1(kcontrol, &status1);
1984 if (err < 0)
1985 return err;
1986 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1);
1987 return 0;
1988}
1989
1990static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol,
1991 struct snd_ctl_elem_value *ucontrol)
1992{
1993 u32 status1;
1994 int err;
1995
1996 err = snd_rme_get_status1(kcontrol, &status1);
1997 if (err < 0)
1998 return err;
1999 ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1);
2000 return 0;
2001}
2002
2003static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol,
2004 struct snd_ctl_elem_value *ucontrol)
2005{
2006 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2007 struct snd_usb_audio *chip = list->mixer->chip;
2008 u32 status1;
2009 const u64 num = 104857600000000ULL;
2010 u32 den;
2011 unsigned int freq;
2012 int err;
2013
2014 err = snd_usb_lock_shutdown(chip);
2015 if (err < 0)
2016 return err;
2017 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1);
2018 if (err < 0)
2019 goto end;
2020 err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den);
2021 if (err < 0)
2022 goto end;
2023 freq = (den == 0) ? 0 : div64_u64(num, den);
2024 freq <<= SND_RME_CLK_FREQMUL(status1);
2025 ucontrol->value.integer.value[0] = freq;
2026
2027end:
2028 snd_usb_unlock_shutdown(chip);
2029 return err;
2030}
2031
2032static int snd_rme_rate_info(struct snd_kcontrol *kcontrol,
2033 struct snd_ctl_elem_info *uinfo)
2034{
2035 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2036 uinfo->count = 1;
2037 switch (kcontrol->private_value) {
2038 case SND_RME_DOMAIN_SYSTEM:
2039 uinfo->value.integer.min = 32000;
2040 uinfo->value.integer.max = 800000;
2041 break;
2042 case SND_RME_DOMAIN_AES:
2043 case SND_RME_DOMAIN_SPDIF:
2044 default:
2045 uinfo->value.integer.min = 0;
2046 uinfo->value.integer.max = 200000;
2047 }
2048 uinfo->value.integer.step = 0;
2049 return 0;
2050}
2051
2052static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol,
2053 struct snd_ctl_elem_info *uinfo)
2054{
2055 static const char *const sync_states[] = {
2056 "No Lock", "Lock", "Sync"
2057 };
2058
2059 return snd_ctl_enum_info(uinfo, 1,
2060 ARRAY_SIZE(sync_states), sync_states);
2061}
2062
2063static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol,
2064 struct snd_ctl_elem_info *uinfo)
2065{
2066 static const char *const spdif_if[] = {
2067 "Coaxial", "Optical"
2068 };
2069
2070 return snd_ctl_enum_info(uinfo, 1,
2071 ARRAY_SIZE(spdif_if), spdif_if);
2072}
2073
2074static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol,
2075 struct snd_ctl_elem_info *uinfo)
2076{
2077 static const char *const optical_type[] = {
2078 "Consumer", "Professional"
2079 };
2080
2081 return snd_ctl_enum_info(uinfo, 1,
2082 ARRAY_SIZE(optical_type), optical_type);
2083}
2084
2085static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol,
2086 struct snd_ctl_elem_info *uinfo)
2087{
2088 static const char *const sync_sources[] = {
2089 "Internal", "AES", "SPDIF", "Internal"
2090 };
2091
2092 return snd_ctl_enum_info(uinfo, 1,
2093 ARRAY_SIZE(sync_sources), sync_sources);
2094}
2095
2096static struct snd_kcontrol_new snd_rme_controls[] = {
2097 {
2098 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2099 .name = "AES Rate",
2100 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2101 .info = snd_rme_rate_info,
2102 .get = snd_rme_rate_get,
2103 .private_value = SND_RME_DOMAIN_AES
2104 },
2105 {
2106 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2107 .name = "AES Sync",
2108 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2109 .info = snd_rme_sync_state_info,
2110 .get = snd_rme_sync_state_get,
2111 .private_value = SND_RME_DOMAIN_AES
2112 },
2113 {
2114 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2115 .name = "SPDIF Rate",
2116 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2117 .info = snd_rme_rate_info,
2118 .get = snd_rme_rate_get,
2119 .private_value = SND_RME_DOMAIN_SPDIF
2120 },
2121 {
2122 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2123 .name = "SPDIF Sync",
2124 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2125 .info = snd_rme_sync_state_info,
2126 .get = snd_rme_sync_state_get,
2127 .private_value = SND_RME_DOMAIN_SPDIF
2128 },
2129 {
2130 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2131 .name = "SPDIF Interface",
2132 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2133 .info = snd_rme_spdif_if_info,
2134 .get = snd_rme_spdif_if_get,
2135 },
2136 {
2137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2138 .name = "SPDIF Format",
2139 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2140 .info = snd_rme_spdif_format_info,
2141 .get = snd_rme_spdif_format_get,
2142 },
2143 {
2144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2145 .name = "Sync Source",
2146 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2147 .info = snd_rme_sync_source_info,
2148 .get = snd_rme_sync_source_get
2149 },
2150 {
2151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2152 .name = "System Rate",
2153 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2154 .info = snd_rme_rate_info,
2155 .get = snd_rme_rate_get,
2156 .private_value = SND_RME_DOMAIN_SYSTEM
2157 },
2158 {
2159 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2160 .name = "Current Frequency",
2161 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2162 .info = snd_rme_rate_info,
2163 .get = snd_rme_current_freq_get
2164 }
2165};
2166
2167static int snd_rme_controls_create(struct usb_mixer_interface *mixer)
2168{
2169 int err, i;
2170
2171 for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) {
2172 err = add_single_ctl_with_resume(mixer, 0,
2173 NULL,
2174 &snd_rme_controls[i],
2175 NULL);
2176 if (err < 0)
2177 return err;
2178 }
2179
2180 return 0;
2181}
2182
2183int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
2184{
2185 int err = 0;
2186
2187 err = snd_usb_soundblaster_remote_init(mixer);
2188 if (err < 0)
2189 return err;
2190
2191 switch (mixer->chip->usb_id) {
2192 /* Tascam US-16x08 */
2193 case USB_ID(0x0644, 0x8047):
2194 err = snd_us16x08_controls_create(mixer);
2195 break;
2196 case USB_ID(0x041e, 0x3020):
2197 case USB_ID(0x041e, 0x3040):
2198 case USB_ID(0x041e, 0x3042):
2199 case USB_ID(0x041e, 0x30df):
2200 case USB_ID(0x041e, 0x3048):
2201 err = snd_audigy2nx_controls_create(mixer);
2202 if (err < 0)
2203 break;
2204 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx",
2205 mixer, snd_audigy2nx_proc_read);
2206 break;
2207
2208 /* EMU0204 */
2209 case USB_ID(0x041e, 0x3f19):
2210 err = snd_emu0204_controls_create(mixer);
2211 break;
2212
2213 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
2214 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
2215 err = snd_c400_create_mixer(mixer);
2216 break;
2217
2218 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
2219 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
2220 err = snd_ftu_create_mixer(mixer);
2221 break;
2222
2223 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
2224 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
2225 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
2226 err = snd_xonar_u1_controls_create(mixer);
2227 break;
2228
2229 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
2230 err = snd_microii_controls_create(mixer);
2231 break;
2232
2233 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */
2234 err = snd_mbox1_create_sync_switch(mixer);
2235 break;
2236
2237 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
2238 err = snd_nativeinstruments_create_mixer(mixer,
2239 snd_nativeinstruments_ta6_mixers,
2240 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
2241 break;
2242
2243 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
2244 err = snd_nativeinstruments_create_mixer(mixer,
2245 snd_nativeinstruments_ta10_mixers,
2246 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
2247 break;
2248
2249 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
2250 /* detection is disabled in mixer_maps.c */
2251 err = snd_create_std_mono_table(mixer, ebox44_table);
2252 break;
2253
2254 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */
2255 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */
2256 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */
2257 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */
2258 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */
2259 err = snd_scarlett_controls_create(mixer);
2260 break;
2261
2262 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
2263 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
2264 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
2265 err = snd_scarlett_gen2_controls_create(mixer);
2266 break;
2267
2268 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
2269 err = snd_soundblaster_e1_switch_create(mixer);
2270 break;
2271 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
2272 err = dell_dock_mixer_init(mixer);
2273 break;
2274
2275 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */
2276 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */
2277 case USB_ID(0x2a39, 0x3fd4): /* RME */
2278 err = snd_rme_controls_create(mixer);
2279 break;
2280 }
2281
2282 return err;
2283}
2284
2285#ifdef CONFIG_PM
2286void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
2287{
2288 switch (mixer->chip->usb_id) {
2289 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
2290 dell_dock_mixer_init(mixer);
2291 break;
2292 }
2293}
2294#endif
2295
2296void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
2297 int unitid)
2298{
2299 if (!mixer->rc_cfg)
2300 return;
2301 /* unit ids specific to Extigy/Audigy 2 NX: */
2302 switch (unitid) {
2303 case 0: /* remote control */
2304 mixer->rc_urb->dev = mixer->chip->dev;
2305 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
2306 break;
2307 case 4: /* digital in jack */
2308 case 7: /* line in jacks */
2309 case 19: /* speaker out jacks */
2310 case 20: /* headphones out jack */
2311 break;
2312 /* live24ext: 4 = line-in jack */
2313 case 3: /* hp-out jack (may actuate Mute) */
2314 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
2315 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
2316 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
2317 break;
2318 default:
2319 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
2320 break;
2321 }
2322}
2323
2324static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
2325 struct usb_mixer_elem_info *cval,
2326 struct snd_kcontrol *kctl)
2327{
2328 /* Approximation using 10 ranges based on output measurement on hw v1.2.
2329 * This seems close to the cubic mapping e.g. alsamixer uses. */
2330 static const DECLARE_TLV_DB_RANGE(scale,
2331 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970),
2332 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160),
2333 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710),
2334 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560),
2335 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324),
2336 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031),
2337 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393),
2338 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032),
2339 32, 40, TLV_DB_MINMAX_ITEM(-968, -490),
2340 41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
2341 );
2342
2343 if (cval->min == 0 && cval->max == 50) {
2344 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
2345 kctl->tlv.p = scale;
2346 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
2347 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
2348
2349 } else if (cval->min == 0 && cval->max <= 1000) {
2350 /* Some other clearly broken DragonFly variant.
2351 * At least a 0..53 variant (hw v1.0) exists.
2352 */
2353 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
2354 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
2355 }
2356}
2357
2358void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
2359 struct usb_mixer_elem_info *cval, int unitid,
2360 struct snd_kcontrol *kctl)
2361{
2362 switch (mixer->chip->usb_id) {
2363 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
2364 if (unitid == 7 && cval->control == UAC_FU_VOLUME)
2365 snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
2366 break;
2367 /* lowest playback value is muted on C-Media devices */
2368 case USB_ID(0x0d8c, 0x000c):
2369 case USB_ID(0x0d8c, 0x0014):
2370 if (strstr(kctl->id.name, "Playback"))
2371 cval->min_mute = 1;
2372 break;
2373 }
2374}
2375