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/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 "mixer_s1810c.h"
38#include "helper.h"
39
40struct std_mono_table {
41 unsigned int unitid, control, cmask;
42 int val_type;
43 const char *name;
44 snd_kcontrol_tlv_rw_t *tlv_callback;
45};
46
47/* This function allows for the creation of standard UAC controls.
48 * See the quirks for M-Audio FTUs or Ebox-44.
49 * If you don't want to set a TLV callback pass NULL.
50 *
51 * Since there doesn't seem to be a devices that needs a multichannel
52 * version, we keep it mono for simplicity.
53 */
54static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
55 unsigned int unitid,
56 unsigned int control,
57 unsigned int cmask,
58 int val_type,
59 unsigned int idx_off,
60 const char *name,
61 snd_kcontrol_tlv_rw_t *tlv_callback)
62{
63 struct usb_mixer_elem_info *cval;
64 struct snd_kcontrol *kctl;
65
66 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
67 if (!cval)
68 return -ENOMEM;
69
70 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
71 cval->val_type = val_type;
72 cval->channels = 1;
73 cval->control = control;
74 cval->cmask = cmask;
75 cval->idx_off = idx_off;
76
77 /* get_min_max() is called only for integer volumes later,
78 * so provide a short-cut for booleans */
79 cval->min = 0;
80 cval->max = 1;
81 cval->res = 0;
82 cval->dBmin = 0;
83 cval->dBmax = 0;
84
85 /* Create control */
86 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
87 if (!kctl) {
88 kfree(cval);
89 return -ENOMEM;
90 }
91
92 /* Set name */
93 snprintf(kctl->id.name, sizeof(kctl->id.name), name);
94 kctl->private_free = snd_usb_mixer_elem_free;
95
96 /* set TLV */
97 if (tlv_callback) {
98 kctl->tlv.c = tlv_callback;
99 kctl->vd[0].access |=
100 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
101 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
102 }
103 /* Add control to mixer */
104 return snd_usb_mixer_add_control(&cval->head, kctl);
105}
106
107static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
108 unsigned int unitid,
109 unsigned int control,
110 unsigned int cmask,
111 int val_type,
112 const char *name,
113 snd_kcontrol_tlv_rw_t *tlv_callback)
114{
115 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
116 val_type, 0 /* Offset */, name, tlv_callback);
117}
118
119/*
120 * Create a set of standard UAC controls from a table
121 */
122static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
123 const struct std_mono_table *t)
124{
125 int err;
126
127 while (t->name != NULL) {
128 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
129 t->cmask, t->val_type, t->name, t->tlv_callback);
130 if (err < 0)
131 return err;
132 t++;
133 }
134
135 return 0;
136}
137
138static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer,
139 int id,
140 usb_mixer_elem_resume_func_t resume,
141 const struct snd_kcontrol_new *knew,
142 struct usb_mixer_elem_list **listp)
143{
144 struct usb_mixer_elem_list *list;
145 struct snd_kcontrol *kctl;
146
147 list = kzalloc(sizeof(*list), GFP_KERNEL);
148 if (!list)
149 return -ENOMEM;
150 if (listp)
151 *listp = list;
152 list->mixer = mixer;
153 list->id = id;
154 list->resume = resume;
155 kctl = snd_ctl_new1(knew, list);
156 if (!kctl) {
157 kfree(list);
158 return -ENOMEM;
159 }
160 kctl->private_free = snd_usb_mixer_elem_free;
161 /* don't use snd_usb_mixer_add_control() here, this is a special list element */
162 return snd_usb_mixer_add_list(list, kctl, false);
163}
164
165/*
166 * Sound Blaster remote control configuration
167 *
168 * format of remote control data:
169 * Extigy: xx 00
170 * Audigy 2 NX: 06 80 xx 00 00 00
171 * Live! 24-bit: 06 80 xx yy 22 83
172 */
173static const struct rc_config {
174 u32 usb_id;
175 u8 offset;
176 u8 length;
177 u8 packet_length;
178 u8 min_packet_length; /* minimum accepted length of the URB result */
179 u8 mute_mixer_id;
180 u32 mute_code;
181} rc_configs[] = {
182 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
183 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
184 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
185 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
186 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
187 { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
188 { USB_ID(0x041e, 0x3263), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
189 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
190};
191
192static void snd_usb_soundblaster_remote_complete(struct urb *urb)
193{
194 struct usb_mixer_interface *mixer = urb->context;
195 const struct rc_config *rc = mixer->rc_cfg;
196 u32 code;
197
198 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
199 return;
200
201 code = mixer->rc_buffer[rc->offset];
202 if (rc->length == 2)
203 code |= mixer->rc_buffer[rc->offset + 1] << 8;
204
205 /* the Mute button actually changes the mixer control */
206 if (code == rc->mute_code)
207 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
208 mixer->rc_code = code;
209 wmb();
210 wake_up(&mixer->rc_waitq);
211}
212
213static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
214 long count, loff_t *offset)
215{
216 struct usb_mixer_interface *mixer = hw->private_data;
217 int err;
218 u32 rc_code;
219
220 if (count != 1 && count != 4)
221 return -EINVAL;
222 err = wait_event_interruptible(mixer->rc_waitq,
223 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
224 if (err == 0) {
225 if (count == 1)
226 err = put_user(rc_code, buf);
227 else
228 err = put_user(rc_code, (u32 __user *)buf);
229 }
230 return err < 0 ? err : count;
231}
232
233static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
234 poll_table *wait)
235{
236 struct usb_mixer_interface *mixer = hw->private_data;
237
238 poll_wait(file, &mixer->rc_waitq, wait);
239 return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0;
240}
241
242static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
243{
244 struct snd_hwdep *hwdep;
245 int err, len, i;
246
247 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
248 if (rc_configs[i].usb_id == mixer->chip->usb_id)
249 break;
250 if (i >= ARRAY_SIZE(rc_configs))
251 return 0;
252 mixer->rc_cfg = &rc_configs[i];
253
254 len = mixer->rc_cfg->packet_length;
255
256 init_waitqueue_head(&mixer->rc_waitq);
257 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
258 if (err < 0)
259 return err;
260 snprintf(hwdep->name, sizeof(hwdep->name),
261 "%s remote control", mixer->chip->card->shortname);
262 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
263 hwdep->private_data = mixer;
264 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
265 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
266 hwdep->exclusive = 1;
267
268 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
269 if (!mixer->rc_urb)
270 return -ENOMEM;
271 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
272 if (!mixer->rc_setup_packet) {
273 usb_free_urb(mixer->rc_urb);
274 mixer->rc_urb = NULL;
275 return -ENOMEM;
276 }
277 mixer->rc_setup_packet->bRequestType =
278 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
279 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
280 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
281 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
282 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
283 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
284 usb_rcvctrlpipe(mixer->chip->dev, 0),
285 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
286 snd_usb_soundblaster_remote_complete, mixer);
287 return 0;
288}
289
290#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
291
292static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
293{
294 ucontrol->value.integer.value[0] = kcontrol->private_value >> 8;
295 return 0;
296}
297
298static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer,
299 int value, int index)
300{
301 struct snd_usb_audio *chip = mixer->chip;
302 int err;
303
304 err = snd_usb_lock_shutdown(chip);
305 if (err < 0)
306 return err;
307
308 if (chip->usb_id == USB_ID(0x041e, 0x3042))
309 err = snd_usb_ctl_msg(chip->dev,
310 usb_sndctrlpipe(chip->dev, 0), 0x24,
311 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
312 !value, 0, NULL, 0);
313 /* USB X-Fi S51 Pro */
314 if (chip->usb_id == USB_ID(0x041e, 0x30df))
315 err = snd_usb_ctl_msg(chip->dev,
316 usb_sndctrlpipe(chip->dev, 0), 0x24,
317 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
318 !value, 0, NULL, 0);
319 else
320 err = snd_usb_ctl_msg(chip->dev,
321 usb_sndctrlpipe(chip->dev, 0), 0x24,
322 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
323 value, index + 2, NULL, 0);
324 snd_usb_unlock_shutdown(chip);
325 return err;
326}
327
328static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol,
329 struct snd_ctl_elem_value *ucontrol)
330{
331 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
332 struct usb_mixer_interface *mixer = list->mixer;
333 int index = kcontrol->private_value & 0xff;
334 unsigned int value = ucontrol->value.integer.value[0];
335 int old_value = kcontrol->private_value >> 8;
336 int err;
337
338 if (value > 1)
339 return -EINVAL;
340 if (value == old_value)
341 return 0;
342 kcontrol->private_value = (value << 8) | index;
343 err = snd_audigy2nx_led_update(mixer, value, index);
344 return err < 0 ? err : 1;
345}
346
347static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list)
348{
349 int priv_value = list->kctl->private_value;
350
351 return snd_audigy2nx_led_update(list->mixer, priv_value >> 8,
352 priv_value & 0xff);
353}
354
355/* name and private_value are set dynamically */
356static const struct snd_kcontrol_new snd_audigy2nx_control = {
357 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
358 .info = snd_audigy2nx_led_info,
359 .get = snd_audigy2nx_led_get,
360 .put = snd_audigy2nx_led_put,
361};
362
363static const char * const snd_audigy2nx_led_names[] = {
364 "CMSS LED Switch",
365 "Power LED Switch",
366 "Dolby Digital LED Switch",
367};
368
369static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
370{
371 int i, err;
372
373 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) {
374 struct snd_kcontrol_new knew;
375
376 /* USB X-Fi S51 doesn't have a CMSS LED */
377 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
378 continue;
379 /* USB X-Fi S51 Pro doesn't have one either */
380 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
381 continue;
382 if (i > 1 && /* Live24ext has 2 LEDs only */
383 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
384 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
385 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
386 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
387 break;
388
389 knew = snd_audigy2nx_control;
390 knew.name = snd_audigy2nx_led_names[i];
391 knew.private_value = (1 << 8) | i; /* LED on as default */
392 err = add_single_ctl_with_resume(mixer, 0,
393 snd_audigy2nx_led_resume,
394 &knew, NULL);
395 if (err < 0)
396 return err;
397 }
398 return 0;
399}
400
401static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
402 struct snd_info_buffer *buffer)
403{
404 static const struct sb_jack {
405 int unitid;
406 const char *name;
407 } jacks_audigy2nx[] = {
408 {4, "dig in "},
409 {7, "line in"},
410 {19, "spk out"},
411 {20, "hph out"},
412 {-1, NULL}
413 }, jacks_live24ext[] = {
414 {4, "line in"}, /* &1=Line, &2=Mic*/
415 {3, "hph out"}, /* headphones */
416 {0, "RC "}, /* last command, 6 bytes see rc_config above */
417 {-1, NULL}
418 };
419 const struct sb_jack *jacks;
420 struct usb_mixer_interface *mixer = entry->private_data;
421 int i, err;
422 u8 buf[3];
423
424 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
425 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
426 jacks = jacks_audigy2nx;
427 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
428 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
429 jacks = jacks_live24ext;
430 else
431 return;
432
433 for (i = 0; jacks[i].name; ++i) {
434 snd_iprintf(buffer, "%s: ", jacks[i].name);
435 err = snd_usb_lock_shutdown(mixer->chip);
436 if (err < 0)
437 return;
438 err = snd_usb_ctl_msg(mixer->chip->dev,
439 usb_rcvctrlpipe(mixer->chip->dev, 0),
440 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
441 USB_RECIP_INTERFACE, 0,
442 jacks[i].unitid << 8, buf, 3);
443 snd_usb_unlock_shutdown(mixer->chip);
444 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
445 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
446 else
447 snd_iprintf(buffer, "?\n");
448 }
449}
450
451/* EMU0204 */
452static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
453 struct snd_ctl_elem_info *uinfo)
454{
455 static const char * const texts[2] = {"1/2", "3/4"};
456
457 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
458}
459
460static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
461 struct snd_ctl_elem_value *ucontrol)
462{
463 ucontrol->value.enumerated.item[0] = kcontrol->private_value;
464 return 0;
465}
466
467static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer,
468 int value)
469{
470 struct snd_usb_audio *chip = mixer->chip;
471 int err;
472 unsigned char buf[2];
473
474 err = snd_usb_lock_shutdown(chip);
475 if (err < 0)
476 return err;
477
478 buf[0] = 0x01;
479 buf[1] = value ? 0x02 : 0x01;
480 err = snd_usb_ctl_msg(chip->dev,
481 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
482 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
483 0x0400, 0x0e00, buf, 2);
484 snd_usb_unlock_shutdown(chip);
485 return err;
486}
487
488static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
489 struct snd_ctl_elem_value *ucontrol)
490{
491 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
492 struct usb_mixer_interface *mixer = list->mixer;
493 unsigned int value = ucontrol->value.enumerated.item[0];
494 int err;
495
496 if (value > 1)
497 return -EINVAL;
498
499 if (value == kcontrol->private_value)
500 return 0;
501
502 kcontrol->private_value = value;
503 err = snd_emu0204_ch_switch_update(mixer, value);
504 return err < 0 ? err : 1;
505}
506
507static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list)
508{
509 return snd_emu0204_ch_switch_update(list->mixer,
510 list->kctl->private_value);
511}
512
513static const struct snd_kcontrol_new snd_emu0204_control = {
514 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
515 .name = "Front Jack Channels",
516 .info = snd_emu0204_ch_switch_info,
517 .get = snd_emu0204_ch_switch_get,
518 .put = snd_emu0204_ch_switch_put,
519 .private_value = 0,
520};
521
522static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
523{
524 return add_single_ctl_with_resume(mixer, 0,
525 snd_emu0204_ch_switch_resume,
526 &snd_emu0204_control, NULL);
527}
528
529/* ASUS Xonar U1 / U3 controls */
530
531static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
532 struct snd_ctl_elem_value *ucontrol)
533{
534 ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02);
535 return 0;
536}
537
538static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer,
539 unsigned char status)
540{
541 struct snd_usb_audio *chip = mixer->chip;
542 int err;
543
544 err = snd_usb_lock_shutdown(chip);
545 if (err < 0)
546 return err;
547 err = snd_usb_ctl_msg(chip->dev,
548 usb_sndctrlpipe(chip->dev, 0), 0x08,
549 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
550 50, 0, &status, 1);
551 snd_usb_unlock_shutdown(chip);
552 return err;
553}
554
555static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
556 struct snd_ctl_elem_value *ucontrol)
557{
558 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
559 u8 old_status, new_status;
560 int err;
561
562 old_status = kcontrol->private_value;
563 if (ucontrol->value.integer.value[0])
564 new_status = old_status | 0x02;
565 else
566 new_status = old_status & ~0x02;
567 if (new_status == old_status)
568 return 0;
569
570 kcontrol->private_value = new_status;
571 err = snd_xonar_u1_switch_update(list->mixer, new_status);
572 return err < 0 ? err : 1;
573}
574
575static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list)
576{
577 return snd_xonar_u1_switch_update(list->mixer,
578 list->kctl->private_value);
579}
580
581static const struct snd_kcontrol_new snd_xonar_u1_output_switch = {
582 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
583 .name = "Digital Playback Switch",
584 .info = snd_ctl_boolean_mono_info,
585 .get = snd_xonar_u1_switch_get,
586 .put = snd_xonar_u1_switch_put,
587 .private_value = 0x05,
588};
589
590static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
591{
592 return add_single_ctl_with_resume(mixer, 0,
593 snd_xonar_u1_switch_resume,
594 &snd_xonar_u1_output_switch, NULL);
595}
596
597/* Digidesign Mbox 1 clock source switch (internal/spdif) */
598
599static int snd_mbox1_switch_get(struct snd_kcontrol *kctl,
600 struct snd_ctl_elem_value *ucontrol)
601{
602 ucontrol->value.enumerated.item[0] = kctl->private_value;
603 return 0;
604}
605
606static int snd_mbox1_switch_update(struct usb_mixer_interface *mixer, int val)
607{
608 struct snd_usb_audio *chip = mixer->chip;
609 int err;
610 unsigned char buff[3];
611
612 err = snd_usb_lock_shutdown(chip);
613 if (err < 0)
614 return err;
615
616 /* Prepare for magic command to toggle clock source */
617 err = snd_usb_ctl_msg(chip->dev,
618 usb_rcvctrlpipe(chip->dev, 0), 0x81,
619 USB_DIR_IN |
620 USB_TYPE_CLASS |
621 USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1);
622 if (err < 0)
623 goto err;
624 err = snd_usb_ctl_msg(chip->dev,
625 usb_rcvctrlpipe(chip->dev, 0), 0x81,
626 USB_DIR_IN |
627 USB_TYPE_CLASS |
628 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
629 if (err < 0)
630 goto err;
631
632 /* 2 possibilities: Internal -> send sample rate
633 * S/PDIF sync -> send zeroes
634 * NB: Sample rate locked to 48kHz on purpose to
635 * prevent user from resetting the sample rate
636 * while S/PDIF sync is enabled and confusing
637 * this configuration.
638 */
639 if (val == 0) {
640 buff[0] = 0x80;
641 buff[1] = 0xbb;
642 buff[2] = 0x00;
643 } else {
644 buff[0] = buff[1] = buff[2] = 0x00;
645 }
646
647 /* Send the magic command to toggle the clock source */
648 err = snd_usb_ctl_msg(chip->dev,
649 usb_sndctrlpipe(chip->dev, 0), 0x1,
650 USB_TYPE_CLASS |
651 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
652 if (err < 0)
653 goto err;
654 err = snd_usb_ctl_msg(chip->dev,
655 usb_rcvctrlpipe(chip->dev, 0), 0x81,
656 USB_DIR_IN |
657 USB_TYPE_CLASS |
658 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
659 if (err < 0)
660 goto err;
661 err = snd_usb_ctl_msg(chip->dev,
662 usb_rcvctrlpipe(chip->dev, 0), 0x81,
663 USB_DIR_IN |
664 USB_TYPE_CLASS |
665 USB_RECIP_ENDPOINT, 0x100, 0x2, buff, 3);
666 if (err < 0)
667 goto err;
668
669err:
670 snd_usb_unlock_shutdown(chip);
671 return err;
672}
673
674static int snd_mbox1_switch_put(struct snd_kcontrol *kctl,
675 struct snd_ctl_elem_value *ucontrol)
676{
677 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
678 struct usb_mixer_interface *mixer = list->mixer;
679 int err;
680 bool cur_val, new_val;
681
682 cur_val = kctl->private_value;
683 new_val = ucontrol->value.enumerated.item[0];
684 if (cur_val == new_val)
685 return 0;
686
687 kctl->private_value = new_val;
688 err = snd_mbox1_switch_update(mixer, new_val);
689 return err < 0 ? err : 1;
690}
691
692static int snd_mbox1_switch_info(struct snd_kcontrol *kcontrol,
693 struct snd_ctl_elem_info *uinfo)
694{
695 static const char *const texts[2] = {
696 "Internal",
697 "S/PDIF"
698 };
699
700 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
701}
702
703static int snd_mbox1_switch_resume(struct usb_mixer_elem_list *list)
704{
705 return snd_mbox1_switch_update(list->mixer, list->kctl->private_value);
706}
707
708static const struct snd_kcontrol_new snd_mbox1_switch = {
709 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
710 .name = "Clock Source",
711 .index = 0,
712 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
713 .info = snd_mbox1_switch_info,
714 .get = snd_mbox1_switch_get,
715 .put = snd_mbox1_switch_put,
716 .private_value = 0
717};
718
719static int snd_mbox1_create_sync_switch(struct usb_mixer_interface *mixer)
720{
721 return add_single_ctl_with_resume(mixer, 0,
722 snd_mbox1_switch_resume,
723 &snd_mbox1_switch, NULL);
724}
725
726/* Native Instruments device quirks */
727
728#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
729
730static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
731 struct snd_kcontrol *kctl)
732{
733 struct usb_device *dev = mixer->chip->dev;
734 unsigned int pval = kctl->private_value;
735 u8 value;
736 int err;
737
738 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
739 (pval >> 16) & 0xff,
740 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
741 0, pval & 0xffff, &value, 1);
742 if (err < 0) {
743 dev_err(&dev->dev,
744 "unable to issue vendor read request (ret = %d)", err);
745 return err;
746 }
747
748 kctl->private_value |= ((unsigned int)value << 24);
749 return 0;
750}
751
752static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
753 struct snd_ctl_elem_value *ucontrol)
754{
755 ucontrol->value.integer.value[0] = kcontrol->private_value >> 24;
756 return 0;
757}
758
759static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list)
760{
761 struct snd_usb_audio *chip = list->mixer->chip;
762 unsigned int pval = list->kctl->private_value;
763 int err;
764
765 err = snd_usb_lock_shutdown(chip);
766 if (err < 0)
767 return err;
768 err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
769 (pval >> 16) & 0xff,
770 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
771 pval >> 24, pval & 0xffff, NULL, 0, 1000);
772 snd_usb_unlock_shutdown(chip);
773 return err;
774}
775
776static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
777 struct snd_ctl_elem_value *ucontrol)
778{
779 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
780 u8 oldval = (kcontrol->private_value >> 24) & 0xff;
781 u8 newval = ucontrol->value.integer.value[0];
782 int err;
783
784 if (oldval == newval)
785 return 0;
786
787 kcontrol->private_value &= ~(0xff << 24);
788 kcontrol->private_value |= (unsigned int)newval << 24;
789 err = snd_ni_update_cur_val(list);
790 return err < 0 ? err : 1;
791}
792
793static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
794 {
795 .name = "Direct Thru Channel A",
796 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
797 },
798 {
799 .name = "Direct Thru Channel B",
800 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
801 },
802 {
803 .name = "Phono Input Channel A",
804 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
805 },
806 {
807 .name = "Phono Input Channel B",
808 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
809 },
810};
811
812static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
813 {
814 .name = "Direct Thru Channel A",
815 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
816 },
817 {
818 .name = "Direct Thru Channel B",
819 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
820 },
821 {
822 .name = "Direct Thru Channel C",
823 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
824 },
825 {
826 .name = "Direct Thru Channel D",
827 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
828 },
829 {
830 .name = "Phono Input Channel A",
831 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
832 },
833 {
834 .name = "Phono Input Channel B",
835 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
836 },
837 {
838 .name = "Phono Input Channel C",
839 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
840 },
841 {
842 .name = "Phono Input Channel D",
843 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
844 },
845};
846
847static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
848 const struct snd_kcontrol_new *kc,
849 unsigned int count)
850{
851 int i, err = 0;
852 struct snd_kcontrol_new template = {
853 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
854 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
855 .get = snd_nativeinstruments_control_get,
856 .put = snd_nativeinstruments_control_put,
857 .info = snd_ctl_boolean_mono_info,
858 };
859
860 for (i = 0; i < count; i++) {
861 struct usb_mixer_elem_list *list;
862
863 template.name = kc[i].name;
864 template.private_value = kc[i].private_value;
865
866 err = add_single_ctl_with_resume(mixer, 0,
867 snd_ni_update_cur_val,
868 &template, &list);
869 if (err < 0)
870 break;
871 snd_ni_control_init_val(mixer, list->kctl);
872 }
873
874 return err;
875}
876
877/* M-Audio FastTrack Ultra quirks */
878/* FTU Effect switch (also used by C400/C600) */
879static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
880 struct snd_ctl_elem_info *uinfo)
881{
882 static const char *const texts[8] = {
883 "Room 1", "Room 2", "Room 3", "Hall 1",
884 "Hall 2", "Plate", "Delay", "Echo"
885 };
886
887 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
888}
889
890static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
891 struct snd_kcontrol *kctl)
892{
893 struct usb_device *dev = mixer->chip->dev;
894 unsigned int pval = kctl->private_value;
895 int err;
896 unsigned char value[2];
897
898 value[0] = 0x00;
899 value[1] = 0x00;
900
901 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
902 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
903 pval & 0xff00,
904 snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8),
905 value, 2);
906 if (err < 0)
907 return err;
908
909 kctl->private_value |= (unsigned int)value[0] << 24;
910 return 0;
911}
912
913static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
914 struct snd_ctl_elem_value *ucontrol)
915{
916 ucontrol->value.enumerated.item[0] = kctl->private_value >> 24;
917 return 0;
918}
919
920static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list)
921{
922 struct snd_usb_audio *chip = list->mixer->chip;
923 unsigned int pval = list->kctl->private_value;
924 unsigned char value[2];
925 int err;
926
927 value[0] = pval >> 24;
928 value[1] = 0;
929
930 err = snd_usb_lock_shutdown(chip);
931 if (err < 0)
932 return err;
933 err = snd_usb_ctl_msg(chip->dev,
934 usb_sndctrlpipe(chip->dev, 0),
935 UAC_SET_CUR,
936 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
937 pval & 0xff00,
938 snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8),
939 value, 2);
940 snd_usb_unlock_shutdown(chip);
941 return err;
942}
943
944static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
945 struct snd_ctl_elem_value *ucontrol)
946{
947 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
948 unsigned int pval = list->kctl->private_value;
949 int cur_val, err, new_val;
950
951 cur_val = pval >> 24;
952 new_val = ucontrol->value.enumerated.item[0];
953 if (cur_val == new_val)
954 return 0;
955
956 kctl->private_value &= ~(0xff << 24);
957 kctl->private_value |= new_val << 24;
958 err = snd_ftu_eff_switch_update(list);
959 return err < 0 ? err : 1;
960}
961
962static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
963 int validx, int bUnitID)
964{
965 static struct snd_kcontrol_new template = {
966 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
967 .name = "Effect Program Switch",
968 .index = 0,
969 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
970 .info = snd_ftu_eff_switch_info,
971 .get = snd_ftu_eff_switch_get,
972 .put = snd_ftu_eff_switch_put
973 };
974 struct usb_mixer_elem_list *list;
975 int err;
976
977 err = add_single_ctl_with_resume(mixer, bUnitID,
978 snd_ftu_eff_switch_update,
979 &template, &list);
980 if (err < 0)
981 return err;
982 list->kctl->private_value = (validx << 8) | bUnitID;
983 snd_ftu_eff_switch_init(mixer, list->kctl);
984 return 0;
985}
986
987/* Create volume controls for FTU devices*/
988static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
989{
990 char name[64];
991 unsigned int control, cmask;
992 int in, out, err;
993
994 const unsigned int id = 5;
995 const int val_type = USB_MIXER_S16;
996
997 for (out = 0; out < 8; out++) {
998 control = out + 1;
999 for (in = 0; in < 8; in++) {
1000 cmask = 1 << in;
1001 snprintf(name, sizeof(name),
1002 "AIn%d - Out%d Capture Volume",
1003 in + 1, out + 1);
1004 err = snd_create_std_mono_ctl(mixer, id, control,
1005 cmask, val_type, name,
1006 &snd_usb_mixer_vol_tlv);
1007 if (err < 0)
1008 return err;
1009 }
1010 for (in = 8; in < 16; in++) {
1011 cmask = 1 << in;
1012 snprintf(name, sizeof(name),
1013 "DIn%d - Out%d Playback Volume",
1014 in - 7, out + 1);
1015 err = snd_create_std_mono_ctl(mixer, id, control,
1016 cmask, val_type, name,
1017 &snd_usb_mixer_vol_tlv);
1018 if (err < 0)
1019 return err;
1020 }
1021 }
1022
1023 return 0;
1024}
1025
1026/* This control needs a volume quirk, see mixer.c */
1027static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1028{
1029 static const char name[] = "Effect Volume";
1030 const unsigned int id = 6;
1031 const int val_type = USB_MIXER_U8;
1032 const unsigned int control = 2;
1033 const unsigned int cmask = 0;
1034
1035 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1036 name, snd_usb_mixer_vol_tlv);
1037}
1038
1039/* This control needs a volume quirk, see mixer.c */
1040static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1041{
1042 static const char name[] = "Effect Duration";
1043 const unsigned int id = 6;
1044 const int val_type = USB_MIXER_S16;
1045 const unsigned int control = 3;
1046 const unsigned int cmask = 0;
1047
1048 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1049 name, snd_usb_mixer_vol_tlv);
1050}
1051
1052/* This control needs a volume quirk, see mixer.c */
1053static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1054{
1055 static const char name[] = "Effect Feedback Volume";
1056 const unsigned int id = 6;
1057 const int val_type = USB_MIXER_U8;
1058 const unsigned int control = 4;
1059 const unsigned int cmask = 0;
1060
1061 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1062 name, NULL);
1063}
1064
1065static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1066{
1067 unsigned int cmask;
1068 int err, ch;
1069 char name[48];
1070
1071 const unsigned int id = 7;
1072 const int val_type = USB_MIXER_S16;
1073 const unsigned int control = 7;
1074
1075 for (ch = 0; ch < 4; ++ch) {
1076 cmask = 1 << ch;
1077 snprintf(name, sizeof(name),
1078 "Effect Return %d Volume", ch + 1);
1079 err = snd_create_std_mono_ctl(mixer, id, control,
1080 cmask, val_type, name,
1081 snd_usb_mixer_vol_tlv);
1082 if (err < 0)
1083 return err;
1084 }
1085
1086 return 0;
1087}
1088
1089static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1090{
1091 unsigned int cmask;
1092 int err, ch;
1093 char name[48];
1094
1095 const unsigned int id = 5;
1096 const int val_type = USB_MIXER_S16;
1097 const unsigned int control = 9;
1098
1099 for (ch = 0; ch < 8; ++ch) {
1100 cmask = 1 << ch;
1101 snprintf(name, sizeof(name),
1102 "Effect Send AIn%d Volume", ch + 1);
1103 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1104 val_type, name,
1105 snd_usb_mixer_vol_tlv);
1106 if (err < 0)
1107 return err;
1108 }
1109 for (ch = 8; ch < 16; ++ch) {
1110 cmask = 1 << ch;
1111 snprintf(name, sizeof(name),
1112 "Effect Send DIn%d Volume", ch - 7);
1113 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1114 val_type, name,
1115 snd_usb_mixer_vol_tlv);
1116 if (err < 0)
1117 return err;
1118 }
1119 return 0;
1120}
1121
1122static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1123{
1124 int err;
1125
1126 err = snd_ftu_create_volume_ctls(mixer);
1127 if (err < 0)
1128 return err;
1129
1130 err = snd_ftu_create_effect_switch(mixer, 1, 6);
1131 if (err < 0)
1132 return err;
1133
1134 err = snd_ftu_create_effect_volume_ctl(mixer);
1135 if (err < 0)
1136 return err;
1137
1138 err = snd_ftu_create_effect_duration_ctl(mixer);
1139 if (err < 0)
1140 return err;
1141
1142 err = snd_ftu_create_effect_feedback_ctl(mixer);
1143 if (err < 0)
1144 return err;
1145
1146 err = snd_ftu_create_effect_return_ctls(mixer);
1147 if (err < 0)
1148 return err;
1149
1150 err = snd_ftu_create_effect_send_ctls(mixer);
1151 if (err < 0)
1152 return err;
1153
1154 return 0;
1155}
1156
1157void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1158 unsigned char samplerate_id)
1159{
1160 struct usb_mixer_interface *mixer;
1161 struct usb_mixer_elem_info *cval;
1162 int unitid = 12; /* SampleRate ExtensionUnit ID */
1163
1164 list_for_each_entry(mixer, &chip->mixer_list, list) {
1165 if (mixer->id_elems[unitid]) {
1166 cval = mixer_elem_list_to_info(mixer->id_elems[unitid]);
1167 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1168 cval->control << 8,
1169 samplerate_id);
1170 snd_usb_mixer_notify_id(mixer, unitid);
1171 break;
1172 }
1173 }
1174}
1175
1176/* M-Audio Fast Track C400/C600 */
1177/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1178static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1179{
1180 char name[64];
1181 unsigned int cmask, offset;
1182 int out, chan, err;
1183 int num_outs = 0;
1184 int num_ins = 0;
1185
1186 const unsigned int id = 0x40;
1187 const int val_type = USB_MIXER_S16;
1188 const int control = 1;
1189
1190 switch (mixer->chip->usb_id) {
1191 case USB_ID(0x0763, 0x2030):
1192 num_outs = 6;
1193 num_ins = 4;
1194 break;
1195 case USB_ID(0x0763, 0x2031):
1196 num_outs = 8;
1197 num_ins = 6;
1198 break;
1199 }
1200
1201 for (chan = 0; chan < num_outs + num_ins; chan++) {
1202 for (out = 0; out < num_outs; out++) {
1203 if (chan < num_outs) {
1204 snprintf(name, sizeof(name),
1205 "PCM%d-Out%d Playback Volume",
1206 chan + 1, out + 1);
1207 } else {
1208 snprintf(name, sizeof(name),
1209 "In%d-Out%d Playback Volume",
1210 chan - num_outs + 1, out + 1);
1211 }
1212
1213 cmask = (out == 0) ? 0 : 1 << (out - 1);
1214 offset = chan * num_outs;
1215 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1216 cmask, val_type, offset, name,
1217 &snd_usb_mixer_vol_tlv);
1218 if (err < 0)
1219 return err;
1220 }
1221 }
1222
1223 return 0;
1224}
1225
1226/* This control needs a volume quirk, see mixer.c */
1227static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1228{
1229 static const char name[] = "Effect Volume";
1230 const unsigned int id = 0x43;
1231 const int val_type = USB_MIXER_U8;
1232 const unsigned int control = 3;
1233 const unsigned int cmask = 0;
1234
1235 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1236 name, snd_usb_mixer_vol_tlv);
1237}
1238
1239/* This control needs a volume quirk, see mixer.c */
1240static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1241{
1242 static const char name[] = "Effect Duration";
1243 const unsigned int id = 0x43;
1244 const int val_type = USB_MIXER_S16;
1245 const unsigned int control = 4;
1246 const unsigned int cmask = 0;
1247
1248 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1249 name, snd_usb_mixer_vol_tlv);
1250}
1251
1252/* This control needs a volume quirk, see mixer.c */
1253static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1254{
1255 static const char name[] = "Effect Feedback Volume";
1256 const unsigned int id = 0x43;
1257 const int val_type = USB_MIXER_U8;
1258 const unsigned int control = 5;
1259 const unsigned int cmask = 0;
1260
1261 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1262 name, NULL);
1263}
1264
1265static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1266{
1267 char name[64];
1268 unsigned int cmask;
1269 int chan, err;
1270 int num_outs = 0;
1271 int num_ins = 0;
1272
1273 const unsigned int id = 0x42;
1274 const int val_type = USB_MIXER_S16;
1275 const int control = 1;
1276
1277 switch (mixer->chip->usb_id) {
1278 case USB_ID(0x0763, 0x2030):
1279 num_outs = 6;
1280 num_ins = 4;
1281 break;
1282 case USB_ID(0x0763, 0x2031):
1283 num_outs = 8;
1284 num_ins = 6;
1285 break;
1286 }
1287
1288 for (chan = 0; chan < num_outs + num_ins; chan++) {
1289 if (chan < num_outs) {
1290 snprintf(name, sizeof(name),
1291 "Effect Send DOut%d",
1292 chan + 1);
1293 } else {
1294 snprintf(name, sizeof(name),
1295 "Effect Send AIn%d",
1296 chan - num_outs + 1);
1297 }
1298
1299 cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1300 err = snd_create_std_mono_ctl(mixer, id, control,
1301 cmask, val_type, name,
1302 &snd_usb_mixer_vol_tlv);
1303 if (err < 0)
1304 return err;
1305 }
1306
1307 return 0;
1308}
1309
1310static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1311{
1312 char name[64];
1313 unsigned int cmask;
1314 int chan, err;
1315 int num_outs = 0;
1316 int offset = 0;
1317
1318 const unsigned int id = 0x40;
1319 const int val_type = USB_MIXER_S16;
1320 const int control = 1;
1321
1322 switch (mixer->chip->usb_id) {
1323 case USB_ID(0x0763, 0x2030):
1324 num_outs = 6;
1325 offset = 0x3c;
1326 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1327 break;
1328 case USB_ID(0x0763, 0x2031):
1329 num_outs = 8;
1330 offset = 0x70;
1331 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1332 break;
1333 }
1334
1335 for (chan = 0; chan < num_outs; chan++) {
1336 snprintf(name, sizeof(name),
1337 "Effect Return %d",
1338 chan + 1);
1339
1340 cmask = (chan == 0) ? 0 :
1341 1 << (chan + (chan % 2) * num_outs - 1);
1342 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1343 cmask, val_type, offset, name,
1344 &snd_usb_mixer_vol_tlv);
1345 if (err < 0)
1346 return err;
1347 }
1348
1349 return 0;
1350}
1351
1352static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1353{
1354 int err;
1355
1356 err = snd_c400_create_vol_ctls(mixer);
1357 if (err < 0)
1358 return err;
1359
1360 err = snd_c400_create_effect_vol_ctls(mixer);
1361 if (err < 0)
1362 return err;
1363
1364 err = snd_c400_create_effect_ret_vol_ctls(mixer);
1365 if (err < 0)
1366 return err;
1367
1368 err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1369 if (err < 0)
1370 return err;
1371
1372 err = snd_c400_create_effect_volume_ctl(mixer);
1373 if (err < 0)
1374 return err;
1375
1376 err = snd_c400_create_effect_duration_ctl(mixer);
1377 if (err < 0)
1378 return err;
1379
1380 err = snd_c400_create_effect_feedback_ctl(mixer);
1381 if (err < 0)
1382 return err;
1383
1384 return 0;
1385}
1386
1387/*
1388 * The mixer units for Ebox-44 are corrupt, and even where they
1389 * are valid they presents mono controls as L and R channels of
1390 * stereo. So we provide a good mixer here.
1391 */
1392static const struct std_mono_table ebox44_table[] = {
1393 {
1394 .unitid = 4,
1395 .control = 1,
1396 .cmask = 0x0,
1397 .val_type = USB_MIXER_INV_BOOLEAN,
1398 .name = "Headphone Playback Switch"
1399 },
1400 {
1401 .unitid = 4,
1402 .control = 2,
1403 .cmask = 0x1,
1404 .val_type = USB_MIXER_S16,
1405 .name = "Headphone A Mix Playback Volume"
1406 },
1407 {
1408 .unitid = 4,
1409 .control = 2,
1410 .cmask = 0x2,
1411 .val_type = USB_MIXER_S16,
1412 .name = "Headphone B Mix Playback Volume"
1413 },
1414
1415 {
1416 .unitid = 7,
1417 .control = 1,
1418 .cmask = 0x0,
1419 .val_type = USB_MIXER_INV_BOOLEAN,
1420 .name = "Output Playback Switch"
1421 },
1422 {
1423 .unitid = 7,
1424 .control = 2,
1425 .cmask = 0x1,
1426 .val_type = USB_MIXER_S16,
1427 .name = "Output A Playback Volume"
1428 },
1429 {
1430 .unitid = 7,
1431 .control = 2,
1432 .cmask = 0x2,
1433 .val_type = USB_MIXER_S16,
1434 .name = "Output B Playback Volume"
1435 },
1436
1437 {
1438 .unitid = 10,
1439 .control = 1,
1440 .cmask = 0x0,
1441 .val_type = USB_MIXER_INV_BOOLEAN,
1442 .name = "Input Capture Switch"
1443 },
1444 {
1445 .unitid = 10,
1446 .control = 2,
1447 .cmask = 0x1,
1448 .val_type = USB_MIXER_S16,
1449 .name = "Input A Capture Volume"
1450 },
1451 {
1452 .unitid = 10,
1453 .control = 2,
1454 .cmask = 0x2,
1455 .val_type = USB_MIXER_S16,
1456 .name = "Input B Capture Volume"
1457 },
1458
1459 {}
1460};
1461
1462/* Audio Advantage Micro II findings:
1463 *
1464 * Mapping spdif AES bits to vendor register.bit:
1465 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1466 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1467 * AES2: [0 0 0 0 0 0 0 0]
1468 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1469 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1470 *
1471 * power on values:
1472 * r2: 0x10
1473 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1474 * just after it to 0xa0, presumably it disables/mutes some analog
1475 * parts when there is no audio.)
1476 * r9: 0x28
1477 *
1478 * Optical transmitter on/off:
1479 * vendor register.bit: 9.1
1480 * 0 - on (0x28 register value)
1481 * 1 - off (0x2a register value)
1482 *
1483 */
1484static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1485 struct snd_ctl_elem_info *uinfo)
1486{
1487 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1488 uinfo->count = 1;
1489 return 0;
1490}
1491
1492static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1493 struct snd_ctl_elem_value *ucontrol)
1494{
1495 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1496 struct snd_usb_audio *chip = list->mixer->chip;
1497 int err;
1498 struct usb_interface *iface;
1499 struct usb_host_interface *alts;
1500 unsigned int ep;
1501 unsigned char data[3];
1502 int rate;
1503
1504 err = snd_usb_lock_shutdown(chip);
1505 if (err < 0)
1506 return err;
1507
1508 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1509 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1510 ucontrol->value.iec958.status[2] = 0x00;
1511
1512 /* use known values for that card: interface#1 altsetting#1 */
1513 iface = usb_ifnum_to_if(chip->dev, 1);
1514 if (!iface || iface->num_altsetting < 2) {
1515 err = -EINVAL;
1516 goto end;
1517 }
1518 alts = &iface->altsetting[1];
1519 if (get_iface_desc(alts)->bNumEndpoints < 1) {
1520 err = -EINVAL;
1521 goto end;
1522 }
1523 ep = get_endpoint(alts, 0)->bEndpointAddress;
1524
1525 err = snd_usb_ctl_msg(chip->dev,
1526 usb_rcvctrlpipe(chip->dev, 0),
1527 UAC_GET_CUR,
1528 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1529 UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1530 ep,
1531 data,
1532 sizeof(data));
1533 if (err < 0)
1534 goto end;
1535
1536 rate = data[0] | (data[1] << 8) | (data[2] << 16);
1537 ucontrol->value.iec958.status[3] = (rate == 48000) ?
1538 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1539
1540 err = 0;
1541 end:
1542 snd_usb_unlock_shutdown(chip);
1543 return err;
1544}
1545
1546static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list)
1547{
1548 struct snd_usb_audio *chip = list->mixer->chip;
1549 unsigned int pval = list->kctl->private_value;
1550 u8 reg;
1551 int err;
1552
1553 err = snd_usb_lock_shutdown(chip);
1554 if (err < 0)
1555 return err;
1556
1557 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f);
1558 err = snd_usb_ctl_msg(chip->dev,
1559 usb_sndctrlpipe(chip->dev, 0),
1560 UAC_SET_CUR,
1561 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1562 reg,
1563 2,
1564 NULL,
1565 0);
1566 if (err < 0)
1567 goto end;
1568
1569 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20;
1570 reg |= (pval >> 12) & 0x0f;
1571 err = snd_usb_ctl_msg(chip->dev,
1572 usb_sndctrlpipe(chip->dev, 0),
1573 UAC_SET_CUR,
1574 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1575 reg,
1576 3,
1577 NULL,
1578 0);
1579 if (err < 0)
1580 goto end;
1581
1582 end:
1583 snd_usb_unlock_shutdown(chip);
1584 return err;
1585}
1586
1587static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1588 struct snd_ctl_elem_value *ucontrol)
1589{
1590 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1591 unsigned int pval, pval_old;
1592 int err;
1593
1594 pval = pval_old = kcontrol->private_value;
1595 pval &= 0xfffff0f0;
1596 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1597 pval |= (ucontrol->value.iec958.status[0] & 0x0f);
1598
1599 pval &= 0xffff0fff;
1600 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1601
1602 /* The frequency bits in AES3 cannot be set via register access. */
1603
1604 /* Silently ignore any bits from the request that cannot be set. */
1605
1606 if (pval == pval_old)
1607 return 0;
1608
1609 kcontrol->private_value = pval;
1610 err = snd_microii_spdif_default_update(list);
1611 return err < 0 ? err : 1;
1612}
1613
1614static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1615 struct snd_ctl_elem_value *ucontrol)
1616{
1617 ucontrol->value.iec958.status[0] = 0x0f;
1618 ucontrol->value.iec958.status[1] = 0xff;
1619 ucontrol->value.iec958.status[2] = 0x00;
1620 ucontrol->value.iec958.status[3] = 0x00;
1621
1622 return 0;
1623}
1624
1625static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1626 struct snd_ctl_elem_value *ucontrol)
1627{
1628 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1629
1630 return 0;
1631}
1632
1633static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list)
1634{
1635 struct snd_usb_audio *chip = list->mixer->chip;
1636 u8 reg = list->kctl->private_value;
1637 int err;
1638
1639 err = snd_usb_lock_shutdown(chip);
1640 if (err < 0)
1641 return err;
1642
1643 err = snd_usb_ctl_msg(chip->dev,
1644 usb_sndctrlpipe(chip->dev, 0),
1645 UAC_SET_CUR,
1646 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1647 reg,
1648 9,
1649 NULL,
1650 0);
1651
1652 snd_usb_unlock_shutdown(chip);
1653 return err;
1654}
1655
1656static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1657 struct snd_ctl_elem_value *ucontrol)
1658{
1659 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1660 u8 reg;
1661 int err;
1662
1663 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1664 if (reg != list->kctl->private_value)
1665 return 0;
1666
1667 kcontrol->private_value = reg;
1668 err = snd_microii_spdif_switch_update(list);
1669 return err < 0 ? err : 1;
1670}
1671
1672static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1673 {
1674 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1675 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1676 .info = snd_microii_spdif_info,
1677 .get = snd_microii_spdif_default_get,
1678 .put = snd_microii_spdif_default_put,
1679 .private_value = 0x00000100UL,/* reset value */
1680 },
1681 {
1682 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1683 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1684 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1685 .info = snd_microii_spdif_info,
1686 .get = snd_microii_spdif_mask_get,
1687 },
1688 {
1689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1690 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1691 .info = snd_ctl_boolean_mono_info,
1692 .get = snd_microii_spdif_switch_get,
1693 .put = snd_microii_spdif_switch_put,
1694 .private_value = 0x00000028UL,/* reset value */
1695 }
1696};
1697
1698static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1699{
1700 int err, i;
1701 static const usb_mixer_elem_resume_func_t resume_funcs[] = {
1702 snd_microii_spdif_default_update,
1703 NULL,
1704 snd_microii_spdif_switch_update
1705 };
1706
1707 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1708 err = add_single_ctl_with_resume(mixer, 0,
1709 resume_funcs[i],
1710 &snd_microii_mixer_spdif[i],
1711 NULL);
1712 if (err < 0)
1713 return err;
1714 }
1715
1716 return 0;
1717}
1718
1719/* Creative Sound Blaster E1 */
1720
1721static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol,
1722 struct snd_ctl_elem_value *ucontrol)
1723{
1724 ucontrol->value.integer.value[0] = kcontrol->private_value;
1725 return 0;
1726}
1727
1728static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer,
1729 unsigned char state)
1730{
1731 struct snd_usb_audio *chip = mixer->chip;
1732 int err;
1733 unsigned char buff[2];
1734
1735 buff[0] = 0x02;
1736 buff[1] = state ? 0x02 : 0x00;
1737
1738 err = snd_usb_lock_shutdown(chip);
1739 if (err < 0)
1740 return err;
1741 err = snd_usb_ctl_msg(chip->dev,
1742 usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT,
1743 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
1744 0x0202, 3, buff, 2);
1745 snd_usb_unlock_shutdown(chip);
1746 return err;
1747}
1748
1749static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol,
1750 struct snd_ctl_elem_value *ucontrol)
1751{
1752 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1753 unsigned char value = !!ucontrol->value.integer.value[0];
1754 int err;
1755
1756 if (kcontrol->private_value == value)
1757 return 0;
1758 kcontrol->private_value = value;
1759 err = snd_soundblaster_e1_switch_update(list->mixer, value);
1760 return err < 0 ? err : 1;
1761}
1762
1763static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list)
1764{
1765 return snd_soundblaster_e1_switch_update(list->mixer,
1766 list->kctl->private_value);
1767}
1768
1769static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol,
1770 struct snd_ctl_elem_info *uinfo)
1771{
1772 static const char *const texts[2] = {
1773 "Mic", "Aux"
1774 };
1775
1776 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1777}
1778
1779static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = {
1780 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1781 .name = "Input Source",
1782 .info = snd_soundblaster_e1_switch_info,
1783 .get = snd_soundblaster_e1_switch_get,
1784 .put = snd_soundblaster_e1_switch_put,
1785 .private_value = 0,
1786};
1787
1788static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer)
1789{
1790 return add_single_ctl_with_resume(mixer, 0,
1791 snd_soundblaster_e1_switch_resume,
1792 &snd_soundblaster_e1_input_switch,
1793 NULL);
1794}
1795
1796static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id)
1797{
1798 u16 buf = 0;
1799
1800 snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
1801 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1802 ch, snd_usb_ctrl_intf(chip) | (id << 8),
1803 &buf, 2);
1804}
1805
1806static int dell_dock_mixer_init(struct usb_mixer_interface *mixer)
1807{
1808 /* fix to 0dB playback volumes */
1809 dell_dock_init_vol(mixer->chip, 1, 16);
1810 dell_dock_init_vol(mixer->chip, 2, 16);
1811 dell_dock_init_vol(mixer->chip, 1, 19);
1812 dell_dock_init_vol(mixer->chip, 2, 19);
1813 return 0;
1814}
1815
1816/* RME Class Compliant device quirks */
1817
1818#define SND_RME_GET_STATUS1 23
1819#define SND_RME_GET_CURRENT_FREQ 17
1820#define SND_RME_CLK_SYSTEM_SHIFT 16
1821#define SND_RME_CLK_SYSTEM_MASK 0x1f
1822#define SND_RME_CLK_AES_SHIFT 8
1823#define SND_RME_CLK_SPDIF_SHIFT 12
1824#define SND_RME_CLK_AES_SPDIF_MASK 0xf
1825#define SND_RME_CLK_SYNC_SHIFT 6
1826#define SND_RME_CLK_SYNC_MASK 0x3
1827#define SND_RME_CLK_FREQMUL_SHIFT 18
1828#define SND_RME_CLK_FREQMUL_MASK 0x7
1829#define SND_RME_CLK_SYSTEM(x) \
1830 ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK)
1831#define SND_RME_CLK_AES(x) \
1832 ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1833#define SND_RME_CLK_SPDIF(x) \
1834 ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1835#define SND_RME_CLK_SYNC(x) \
1836 ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK)
1837#define SND_RME_CLK_FREQMUL(x) \
1838 ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK)
1839#define SND_RME_CLK_AES_LOCK 0x1
1840#define SND_RME_CLK_AES_SYNC 0x4
1841#define SND_RME_CLK_SPDIF_LOCK 0x2
1842#define SND_RME_CLK_SPDIF_SYNC 0x8
1843#define SND_RME_SPDIF_IF_SHIFT 4
1844#define SND_RME_SPDIF_FORMAT_SHIFT 5
1845#define SND_RME_BINARY_MASK 0x1
1846#define SND_RME_SPDIF_IF(x) \
1847 ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK)
1848#define SND_RME_SPDIF_FORMAT(x) \
1849 ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK)
1850
1851static const u32 snd_rme_rate_table[] = {
1852 32000, 44100, 48000, 50000,
1853 64000, 88200, 96000, 100000,
1854 128000, 176400, 192000, 200000,
1855 256000, 352800, 384000, 400000,
1856 512000, 705600, 768000, 800000
1857};
1858/* maximum number of items for AES and S/PDIF rates for above table */
1859#define SND_RME_RATE_IDX_AES_SPDIF_NUM 12
1860
1861enum snd_rme_domain {
1862 SND_RME_DOMAIN_SYSTEM,
1863 SND_RME_DOMAIN_AES,
1864 SND_RME_DOMAIN_SPDIF
1865};
1866
1867enum snd_rme_clock_status {
1868 SND_RME_CLOCK_NOLOCK,
1869 SND_RME_CLOCK_LOCK,
1870 SND_RME_CLOCK_SYNC
1871};
1872
1873static int snd_rme_read_value(struct snd_usb_audio *chip,
1874 unsigned int item,
1875 u32 *value)
1876{
1877 struct usb_device *dev = chip->dev;
1878 int err;
1879
1880 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
1881 item,
1882 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1883 0, 0,
1884 value, sizeof(*value));
1885 if (err < 0)
1886 dev_err(&dev->dev,
1887 "unable to issue vendor read request %d (ret = %d)",
1888 item, err);
1889 return err;
1890}
1891
1892static int snd_rme_get_status1(struct snd_kcontrol *kcontrol,
1893 u32 *status1)
1894{
1895 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1896 struct snd_usb_audio *chip = list->mixer->chip;
1897 int err;
1898
1899 err = snd_usb_lock_shutdown(chip);
1900 if (err < 0)
1901 return err;
1902 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1);
1903 snd_usb_unlock_shutdown(chip);
1904 return err;
1905}
1906
1907static int snd_rme_rate_get(struct snd_kcontrol *kcontrol,
1908 struct snd_ctl_elem_value *ucontrol)
1909{
1910 u32 status1;
1911 u32 rate = 0;
1912 int idx;
1913 int err;
1914
1915 err = snd_rme_get_status1(kcontrol, &status1);
1916 if (err < 0)
1917 return err;
1918 switch (kcontrol->private_value) {
1919 case SND_RME_DOMAIN_SYSTEM:
1920 idx = SND_RME_CLK_SYSTEM(status1);
1921 if (idx < ARRAY_SIZE(snd_rme_rate_table))
1922 rate = snd_rme_rate_table[idx];
1923 break;
1924 case SND_RME_DOMAIN_AES:
1925 idx = SND_RME_CLK_AES(status1);
1926 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
1927 rate = snd_rme_rate_table[idx];
1928 break;
1929 case SND_RME_DOMAIN_SPDIF:
1930 idx = SND_RME_CLK_SPDIF(status1);
1931 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
1932 rate = snd_rme_rate_table[idx];
1933 break;
1934 default:
1935 return -EINVAL;
1936 }
1937 ucontrol->value.integer.value[0] = rate;
1938 return 0;
1939}
1940
1941static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol,
1942 struct snd_ctl_elem_value *ucontrol)
1943{
1944 u32 status1;
1945 int idx = SND_RME_CLOCK_NOLOCK;
1946 int err;
1947
1948 err = snd_rme_get_status1(kcontrol, &status1);
1949 if (err < 0)
1950 return err;
1951 switch (kcontrol->private_value) {
1952 case SND_RME_DOMAIN_AES: /* AES */
1953 if (status1 & SND_RME_CLK_AES_SYNC)
1954 idx = SND_RME_CLOCK_SYNC;
1955 else if (status1 & SND_RME_CLK_AES_LOCK)
1956 idx = SND_RME_CLOCK_LOCK;
1957 break;
1958 case SND_RME_DOMAIN_SPDIF: /* SPDIF */
1959 if (status1 & SND_RME_CLK_SPDIF_SYNC)
1960 idx = SND_RME_CLOCK_SYNC;
1961 else if (status1 & SND_RME_CLK_SPDIF_LOCK)
1962 idx = SND_RME_CLOCK_LOCK;
1963 break;
1964 default:
1965 return -EINVAL;
1966 }
1967 ucontrol->value.enumerated.item[0] = idx;
1968 return 0;
1969}
1970
1971static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol,
1972 struct snd_ctl_elem_value *ucontrol)
1973{
1974 u32 status1;
1975 int err;
1976
1977 err = snd_rme_get_status1(kcontrol, &status1);
1978 if (err < 0)
1979 return err;
1980 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1);
1981 return 0;
1982}
1983
1984static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol,
1985 struct snd_ctl_elem_value *ucontrol)
1986{
1987 u32 status1;
1988 int err;
1989
1990 err = snd_rme_get_status1(kcontrol, &status1);
1991 if (err < 0)
1992 return err;
1993 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1);
1994 return 0;
1995}
1996
1997static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol,
1998 struct snd_ctl_elem_value *ucontrol)
1999{
2000 u32 status1;
2001 int err;
2002
2003 err = snd_rme_get_status1(kcontrol, &status1);
2004 if (err < 0)
2005 return err;
2006 ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1);
2007 return 0;
2008}
2009
2010static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol,
2011 struct snd_ctl_elem_value *ucontrol)
2012{
2013 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2014 struct snd_usb_audio *chip = list->mixer->chip;
2015 u32 status1;
2016 const u64 num = 104857600000000ULL;
2017 u32 den;
2018 unsigned int freq;
2019 int err;
2020
2021 err = snd_usb_lock_shutdown(chip);
2022 if (err < 0)
2023 return err;
2024 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1);
2025 if (err < 0)
2026 goto end;
2027 err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den);
2028 if (err < 0)
2029 goto end;
2030 freq = (den == 0) ? 0 : div64_u64(num, den);
2031 freq <<= SND_RME_CLK_FREQMUL(status1);
2032 ucontrol->value.integer.value[0] = freq;
2033
2034end:
2035 snd_usb_unlock_shutdown(chip);
2036 return err;
2037}
2038
2039static int snd_rme_rate_info(struct snd_kcontrol *kcontrol,
2040 struct snd_ctl_elem_info *uinfo)
2041{
2042 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2043 uinfo->count = 1;
2044 switch (kcontrol->private_value) {
2045 case SND_RME_DOMAIN_SYSTEM:
2046 uinfo->value.integer.min = 32000;
2047 uinfo->value.integer.max = 800000;
2048 break;
2049 case SND_RME_DOMAIN_AES:
2050 case SND_RME_DOMAIN_SPDIF:
2051 default:
2052 uinfo->value.integer.min = 0;
2053 uinfo->value.integer.max = 200000;
2054 }
2055 uinfo->value.integer.step = 0;
2056 return 0;
2057}
2058
2059static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol,
2060 struct snd_ctl_elem_info *uinfo)
2061{
2062 static const char *const sync_states[] = {
2063 "No Lock", "Lock", "Sync"
2064 };
2065
2066 return snd_ctl_enum_info(uinfo, 1,
2067 ARRAY_SIZE(sync_states), sync_states);
2068}
2069
2070static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol,
2071 struct snd_ctl_elem_info *uinfo)
2072{
2073 static const char *const spdif_if[] = {
2074 "Coaxial", "Optical"
2075 };
2076
2077 return snd_ctl_enum_info(uinfo, 1,
2078 ARRAY_SIZE(spdif_if), spdif_if);
2079}
2080
2081static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol,
2082 struct snd_ctl_elem_info *uinfo)
2083{
2084 static const char *const optical_type[] = {
2085 "Consumer", "Professional"
2086 };
2087
2088 return snd_ctl_enum_info(uinfo, 1,
2089 ARRAY_SIZE(optical_type), optical_type);
2090}
2091
2092static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol,
2093 struct snd_ctl_elem_info *uinfo)
2094{
2095 static const char *const sync_sources[] = {
2096 "Internal", "AES", "SPDIF", "Internal"
2097 };
2098
2099 return snd_ctl_enum_info(uinfo, 1,
2100 ARRAY_SIZE(sync_sources), sync_sources);
2101}
2102
2103static const struct snd_kcontrol_new snd_rme_controls[] = {
2104 {
2105 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2106 .name = "AES Rate",
2107 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2108 .info = snd_rme_rate_info,
2109 .get = snd_rme_rate_get,
2110 .private_value = SND_RME_DOMAIN_AES
2111 },
2112 {
2113 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2114 .name = "AES Sync",
2115 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2116 .info = snd_rme_sync_state_info,
2117 .get = snd_rme_sync_state_get,
2118 .private_value = SND_RME_DOMAIN_AES
2119 },
2120 {
2121 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2122 .name = "SPDIF Rate",
2123 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2124 .info = snd_rme_rate_info,
2125 .get = snd_rme_rate_get,
2126 .private_value = SND_RME_DOMAIN_SPDIF
2127 },
2128 {
2129 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2130 .name = "SPDIF Sync",
2131 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2132 .info = snd_rme_sync_state_info,
2133 .get = snd_rme_sync_state_get,
2134 .private_value = SND_RME_DOMAIN_SPDIF
2135 },
2136 {
2137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2138 .name = "SPDIF Interface",
2139 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2140 .info = snd_rme_spdif_if_info,
2141 .get = snd_rme_spdif_if_get,
2142 },
2143 {
2144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2145 .name = "SPDIF Format",
2146 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2147 .info = snd_rme_spdif_format_info,
2148 .get = snd_rme_spdif_format_get,
2149 },
2150 {
2151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2152 .name = "Sync Source",
2153 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2154 .info = snd_rme_sync_source_info,
2155 .get = snd_rme_sync_source_get
2156 },
2157 {
2158 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2159 .name = "System Rate",
2160 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2161 .info = snd_rme_rate_info,
2162 .get = snd_rme_rate_get,
2163 .private_value = SND_RME_DOMAIN_SYSTEM
2164 },
2165 {
2166 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2167 .name = "Current Frequency",
2168 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2169 .info = snd_rme_rate_info,
2170 .get = snd_rme_current_freq_get
2171 }
2172};
2173
2174static int snd_rme_controls_create(struct usb_mixer_interface *mixer)
2175{
2176 int err, i;
2177
2178 for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) {
2179 err = add_single_ctl_with_resume(mixer, 0,
2180 NULL,
2181 &snd_rme_controls[i],
2182 NULL);
2183 if (err < 0)
2184 return err;
2185 }
2186
2187 return 0;
2188}
2189
2190/*
2191 * RME Babyface Pro (FS)
2192 *
2193 * These devices exposes a couple of DSP functions via request to EP0.
2194 * Switches are available via control registers, while routing is controlled
2195 * by controlling the volume on each possible crossing point.
2196 * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with
2197 * 0dB being at dec. 32768.
2198 */
2199enum {
2200 SND_BBFPRO_CTL_REG1 = 0,
2201 SND_BBFPRO_CTL_REG2
2202};
2203
2204#define SND_BBFPRO_CTL_REG_MASK 1
2205#define SND_BBFPRO_CTL_IDX_MASK 0xff
2206#define SND_BBFPRO_CTL_IDX_SHIFT 1
2207#define SND_BBFPRO_CTL_VAL_MASK 1
2208#define SND_BBFPRO_CTL_VAL_SHIFT 9
2209#define SND_BBFPRO_CTL_REG1_CLK_MASTER 0
2210#define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1
2211#define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7
2212#define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8
2213#define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10
2214#define SND_BBFPRO_CTL_REG2_48V_AN1 0
2215#define SND_BBFPRO_CTL_REG2_48V_AN2 1
2216#define SND_BBFPRO_CTL_REG2_SENS_IN3 2
2217#define SND_BBFPRO_CTL_REG2_SENS_IN4 3
2218#define SND_BBFPRO_CTL_REG2_PAD_AN1 4
2219#define SND_BBFPRO_CTL_REG2_PAD_AN2 5
2220
2221#define SND_BBFPRO_MIXER_IDX_MASK 0x1ff
2222#define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff
2223#define SND_BBFPRO_MIXER_VAL_SHIFT 9
2224#define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf
2225#define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB
2226
2227#define SND_BBFPRO_USBREQ_CTL_REG1 0x10
2228#define SND_BBFPRO_USBREQ_CTL_REG2 0x17
2229#define SND_BBFPRO_USBREQ_MIXER 0x12
2230
2231static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg,
2232 u8 index, u8 value)
2233{
2234 int err;
2235 u16 usb_req, usb_idx, usb_val;
2236 struct snd_usb_audio *chip = mixer->chip;
2237
2238 err = snd_usb_lock_shutdown(chip);
2239 if (err < 0)
2240 return err;
2241
2242 if (reg == SND_BBFPRO_CTL_REG1) {
2243 usb_req = SND_BBFPRO_USBREQ_CTL_REG1;
2244 if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2245 usb_idx = 3;
2246 usb_val = value ? 3 : 0;
2247 } else {
2248 usb_idx = 1 << index;
2249 usb_val = value ? usb_idx : 0;
2250 }
2251 } else {
2252 usb_req = SND_BBFPRO_USBREQ_CTL_REG2;
2253 usb_idx = 1 << index;
2254 usb_val = value ? usb_idx : 0;
2255 }
2256
2257 err = snd_usb_ctl_msg(chip->dev,
2258 usb_sndctrlpipe(chip->dev, 0), usb_req,
2259 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2260 usb_val, usb_idx, NULL, 0);
2261
2262 snd_usb_unlock_shutdown(chip);
2263 return err;
2264}
2265
2266static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol,
2267 struct snd_ctl_elem_value *ucontrol)
2268{
2269 u8 reg, idx, val;
2270 int pv;
2271
2272 pv = kcontrol->private_value;
2273 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2274 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2275 val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT;
2276
2277 if ((reg == SND_BBFPRO_CTL_REG1 &&
2278 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2279 (reg == SND_BBFPRO_CTL_REG2 &&
2280 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2281 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2282 ucontrol->value.enumerated.item[0] = val;
2283 } else {
2284 ucontrol->value.integer.value[0] = val;
2285 }
2286 return 0;
2287}
2288
2289static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol,
2290 struct snd_ctl_elem_info *uinfo)
2291{
2292 u8 reg, idx;
2293 int pv;
2294
2295 pv = kcontrol->private_value;
2296 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2297 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2298
2299 if (reg == SND_BBFPRO_CTL_REG1 &&
2300 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2301 static const char * const texts[2] = {
2302 "AutoSync",
2303 "Internal"
2304 };
2305 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2306 } else if (reg == SND_BBFPRO_CTL_REG2 &&
2307 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2308 idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) {
2309 static const char * const texts[2] = {
2310 "-10dBV",
2311 "+4dBu"
2312 };
2313 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2314 }
2315
2316 uinfo->count = 1;
2317 uinfo->value.integer.min = 0;
2318 uinfo->value.integer.max = 1;
2319 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2320 return 0;
2321}
2322
2323static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol,
2324 struct snd_ctl_elem_value *ucontrol)
2325{
2326 int err;
2327 u8 reg, idx;
2328 int old_value, pv, val;
2329
2330 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2331 struct usb_mixer_interface *mixer = list->mixer;
2332
2333 pv = kcontrol->private_value;
2334 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2335 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2336 old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2337
2338 if ((reg == SND_BBFPRO_CTL_REG1 &&
2339 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2340 (reg == SND_BBFPRO_CTL_REG2 &&
2341 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2342 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2343 val = ucontrol->value.enumerated.item[0];
2344 } else {
2345 val = ucontrol->value.integer.value[0];
2346 }
2347
2348 if (val > 1)
2349 return -EINVAL;
2350
2351 if (val == old_value)
2352 return 0;
2353
2354 kcontrol->private_value = reg
2355 | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT)
2356 | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT);
2357
2358 err = snd_bbfpro_ctl_update(mixer, reg, idx, val);
2359 return err < 0 ? err : 1;
2360}
2361
2362static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list)
2363{
2364 u8 reg, idx;
2365 int value, pv;
2366
2367 pv = list->kctl->private_value;
2368 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2369 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2370 value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2371
2372 return snd_bbfpro_ctl_update(list->mixer, reg, idx, value);
2373}
2374
2375static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index,
2376 u32 value)
2377{
2378 struct snd_usb_audio *chip = mixer->chip;
2379 int err;
2380 u16 idx;
2381 u16 usb_idx, usb_val;
2382 u32 v;
2383
2384 err = snd_usb_lock_shutdown(chip);
2385 if (err < 0)
2386 return err;
2387
2388 idx = index & SND_BBFPRO_MIXER_IDX_MASK;
2389 // 18 bit linear volume, split so 2 bits end up in index.
2390 v = value & SND_BBFPRO_MIXER_VAL_MASK;
2391 usb_idx = idx | (v & 0x3) << 14;
2392 usb_val = (v >> 2) & 0xffff;
2393
2394 err = snd_usb_ctl_msg(chip->dev,
2395 usb_sndctrlpipe(chip->dev, 0),
2396 SND_BBFPRO_USBREQ_MIXER,
2397 USB_DIR_OUT | USB_TYPE_VENDOR |
2398 USB_RECIP_DEVICE,
2399 usb_val, usb_idx, NULL, 0);
2400
2401 snd_usb_unlock_shutdown(chip);
2402 return err;
2403}
2404
2405static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol,
2406 struct snd_ctl_elem_value *ucontrol)
2407{
2408 ucontrol->value.integer.value[0] =
2409 kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2410 return 0;
2411}
2412
2413static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol,
2414 struct snd_ctl_elem_info *uinfo)
2415{
2416 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2417 uinfo->count = 1;
2418 uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN;
2419 uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX;
2420 return 0;
2421}
2422
2423static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol,
2424 struct snd_ctl_elem_value *ucontrol)
2425{
2426 int err;
2427 u16 idx;
2428 u32 new_val, old_value, uvalue;
2429 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2430 struct usb_mixer_interface *mixer = list->mixer;
2431
2432 uvalue = ucontrol->value.integer.value[0];
2433 idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK;
2434 old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2435
2436 if (uvalue > SND_BBFPRO_MIXER_VAL_MAX)
2437 return -EINVAL;
2438
2439 if (uvalue == old_value)
2440 return 0;
2441
2442 new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK;
2443
2444 kcontrol->private_value = idx
2445 | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT);
2446
2447 err = snd_bbfpro_vol_update(mixer, idx, new_val);
2448 return err < 0 ? err : 1;
2449}
2450
2451static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list)
2452{
2453 int pv = list->kctl->private_value;
2454 u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK;
2455 u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT)
2456 & SND_BBFPRO_MIXER_VAL_MASK;
2457 return snd_bbfpro_vol_update(list->mixer, idx, val);
2458}
2459
2460// Predfine elements
2461static const struct snd_kcontrol_new snd_bbfpro_ctl_control = {
2462 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2463 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2464 .index = 0,
2465 .info = snd_bbfpro_ctl_info,
2466 .get = snd_bbfpro_ctl_get,
2467 .put = snd_bbfpro_ctl_put
2468};
2469
2470static const struct snd_kcontrol_new snd_bbfpro_vol_control = {
2471 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2472 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2473 .index = 0,
2474 .info = snd_bbfpro_vol_info,
2475 .get = snd_bbfpro_vol_get,
2476 .put = snd_bbfpro_vol_put
2477};
2478
2479static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg,
2480 u8 index, char *name)
2481{
2482 struct snd_kcontrol_new knew = snd_bbfpro_ctl_control;
2483
2484 knew.name = name;
2485 knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK)
2486 | ((index & SND_BBFPRO_CTL_IDX_MASK)
2487 << SND_BBFPRO_CTL_IDX_SHIFT);
2488
2489 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume,
2490 &knew, NULL);
2491}
2492
2493static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index,
2494 char *name)
2495{
2496 struct snd_kcontrol_new knew = snd_bbfpro_vol_control;
2497
2498 knew.name = name;
2499 knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK;
2500
2501 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume,
2502 &knew, NULL);
2503}
2504
2505static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer)
2506{
2507 int err, i, o;
2508 char name[48];
2509
2510 static const char * const input[] = {
2511 "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3",
2512 "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2513
2514 static const char * const output[] = {
2515 "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4",
2516 "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2517
2518 for (o = 0 ; o < 12 ; ++o) {
2519 for (i = 0 ; i < 12 ; ++i) {
2520 // Line routing
2521 snprintf(name, sizeof(name),
2522 "%s-%s-%s Playback Volume",
2523 (i < 2 ? "Mic" : "Line"),
2524 input[i], output[o]);
2525 err = snd_bbfpro_vol_add(mixer, (26 * o + i), name);
2526 if (err < 0)
2527 return err;
2528
2529 // PCM routing... yes, it is output remapping
2530 snprintf(name, sizeof(name),
2531 "PCM-%s-%s Playback Volume",
2532 output[i], output[o]);
2533 err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i),
2534 name);
2535 if (err < 0)
2536 return err;
2537 }
2538 }
2539
2540 // Control Reg 1
2541 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2542 SND_BBFPRO_CTL_REG1_CLK_OPTICAL,
2543 "Sample Clock Source");
2544 if (err < 0)
2545 return err;
2546
2547 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2548 SND_BBFPRO_CTL_REG1_SPDIF_PRO,
2549 "IEC958 Pro Mask");
2550 if (err < 0)
2551 return err;
2552
2553 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2554 SND_BBFPRO_CTL_REG1_SPDIF_EMPH,
2555 "IEC958 Emphasis");
2556 if (err < 0)
2557 return err;
2558
2559 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2560 SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL,
2561 "IEC958 Switch");
2562 if (err < 0)
2563 return err;
2564
2565 // Control Reg 2
2566 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2567 SND_BBFPRO_CTL_REG2_48V_AN1,
2568 "Mic-AN1 48V");
2569 if (err < 0)
2570 return err;
2571
2572 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2573 SND_BBFPRO_CTL_REG2_48V_AN2,
2574 "Mic-AN2 48V");
2575 if (err < 0)
2576 return err;
2577
2578 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2579 SND_BBFPRO_CTL_REG2_SENS_IN3,
2580 "Line-IN3 Sens.");
2581 if (err < 0)
2582 return err;
2583
2584 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2585 SND_BBFPRO_CTL_REG2_SENS_IN4,
2586 "Line-IN4 Sens.");
2587 if (err < 0)
2588 return err;
2589
2590 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2591 SND_BBFPRO_CTL_REG2_PAD_AN1,
2592 "Mic-AN1 PAD");
2593 if (err < 0)
2594 return err;
2595
2596 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2597 SND_BBFPRO_CTL_REG2_PAD_AN2,
2598 "Mic-AN2 PAD");
2599 if (err < 0)
2600 return err;
2601
2602 return 0;
2603}
2604
2605int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
2606{
2607 int err = 0;
2608
2609 err = snd_usb_soundblaster_remote_init(mixer);
2610 if (err < 0)
2611 return err;
2612
2613 switch (mixer->chip->usb_id) {
2614 /* Tascam US-16x08 */
2615 case USB_ID(0x0644, 0x8047):
2616 err = snd_us16x08_controls_create(mixer);
2617 break;
2618 case USB_ID(0x041e, 0x3020):
2619 case USB_ID(0x041e, 0x3040):
2620 case USB_ID(0x041e, 0x3042):
2621 case USB_ID(0x041e, 0x30df):
2622 case USB_ID(0x041e, 0x3048):
2623 err = snd_audigy2nx_controls_create(mixer);
2624 if (err < 0)
2625 break;
2626 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx",
2627 mixer, snd_audigy2nx_proc_read);
2628 break;
2629
2630 /* EMU0204 */
2631 case USB_ID(0x041e, 0x3f19):
2632 err = snd_emu0204_controls_create(mixer);
2633 break;
2634
2635 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
2636 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
2637 err = snd_c400_create_mixer(mixer);
2638 break;
2639
2640 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
2641 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
2642 err = snd_ftu_create_mixer(mixer);
2643 break;
2644
2645 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
2646 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
2647 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
2648 err = snd_xonar_u1_controls_create(mixer);
2649 break;
2650
2651 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
2652 err = snd_microii_controls_create(mixer);
2653 break;
2654
2655 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */
2656 err = snd_mbox1_create_sync_switch(mixer);
2657 break;
2658
2659 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
2660 err = snd_nativeinstruments_create_mixer(mixer,
2661 snd_nativeinstruments_ta6_mixers,
2662 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
2663 break;
2664
2665 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
2666 err = snd_nativeinstruments_create_mixer(mixer,
2667 snd_nativeinstruments_ta10_mixers,
2668 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
2669 break;
2670
2671 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
2672 /* detection is disabled in mixer_maps.c */
2673 err = snd_create_std_mono_table(mixer, ebox44_table);
2674 break;
2675
2676 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */
2677 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */
2678 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */
2679 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */
2680 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */
2681 err = snd_scarlett_controls_create(mixer);
2682 break;
2683
2684 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
2685 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
2686 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
2687 err = snd_scarlett_gen2_controls_create(mixer);
2688 break;
2689
2690 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
2691 err = snd_soundblaster_e1_switch_create(mixer);
2692 break;
2693 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
2694 err = dell_dock_mixer_init(mixer);
2695 break;
2696
2697 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */
2698 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */
2699 case USB_ID(0x2a39, 0x3fd4): /* RME */
2700 err = snd_rme_controls_create(mixer);
2701 break;
2702
2703 case USB_ID(0x0194f, 0x010c): /* Presonus Studio 1810c */
2704 err = snd_sc1810_init_mixer(mixer);
2705 break;
2706 case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */
2707 err = snd_bbfpro_controls_create(mixer);
2708 break;
2709 }
2710
2711 return err;
2712}
2713
2714#ifdef CONFIG_PM
2715void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
2716{
2717 switch (mixer->chip->usb_id) {
2718 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
2719 dell_dock_mixer_init(mixer);
2720 break;
2721 }
2722}
2723#endif
2724
2725void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
2726 int unitid)
2727{
2728 if (!mixer->rc_cfg)
2729 return;
2730 /* unit ids specific to Extigy/Audigy 2 NX: */
2731 switch (unitid) {
2732 case 0: /* remote control */
2733 mixer->rc_urb->dev = mixer->chip->dev;
2734 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
2735 break;
2736 case 4: /* digital in jack */
2737 case 7: /* line in jacks */
2738 case 19: /* speaker out jacks */
2739 case 20: /* headphones out jack */
2740 break;
2741 /* live24ext: 4 = line-in jack */
2742 case 3: /* hp-out jack (may actuate Mute) */
2743 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
2744 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
2745 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
2746 break;
2747 default:
2748 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
2749 break;
2750 }
2751}
2752
2753static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
2754 struct usb_mixer_elem_info *cval,
2755 struct snd_kcontrol *kctl)
2756{
2757 /* Approximation using 10 ranges based on output measurement on hw v1.2.
2758 * This seems close to the cubic mapping e.g. alsamixer uses. */
2759 static const DECLARE_TLV_DB_RANGE(scale,
2760 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970),
2761 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160),
2762 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710),
2763 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560),
2764 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324),
2765 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031),
2766 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393),
2767 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032),
2768 32, 40, TLV_DB_MINMAX_ITEM(-968, -490),
2769 41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
2770 );
2771
2772 if (cval->min == 0 && cval->max == 50) {
2773 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
2774 kctl->tlv.p = scale;
2775 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
2776 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
2777
2778 } else if (cval->min == 0 && cval->max <= 1000) {
2779 /* Some other clearly broken DragonFly variant.
2780 * At least a 0..53 variant (hw v1.0) exists.
2781 */
2782 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
2783 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
2784 }
2785}
2786
2787void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
2788 struct usb_mixer_elem_info *cval, int unitid,
2789 struct snd_kcontrol *kctl)
2790{
2791 switch (mixer->chip->usb_id) {
2792 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
2793 if (unitid == 7 && cval->control == UAC_FU_VOLUME)
2794 snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
2795 break;
2796 /* lowest playback value is muted on C-Media devices */
2797 case USB_ID(0x0d8c, 0x000c):
2798 case USB_ID(0x0d8c, 0x0014):
2799 if (strstr(kctl->id.name, "Playback"))
2800 cval->min_mute = 1;
2801 break;
2802 }
2803}
2804
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 "mixer_s1810c.h"
38#include "helper.h"
39
40struct std_mono_table {
41 unsigned int unitid, control, cmask;
42 int val_type;
43 const char *name;
44 snd_kcontrol_tlv_rw_t *tlv_callback;
45};
46
47/* This function allows for the creation of standard UAC controls.
48 * See the quirks for M-Audio FTUs or Ebox-44.
49 * If you don't want to set a TLV callback pass NULL.
50 *
51 * Since there doesn't seem to be a devices that needs a multichannel
52 * version, we keep it mono for simplicity.
53 */
54static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
55 unsigned int unitid,
56 unsigned int control,
57 unsigned int cmask,
58 int val_type,
59 unsigned int idx_off,
60 const char *name,
61 snd_kcontrol_tlv_rw_t *tlv_callback)
62{
63 struct usb_mixer_elem_info *cval;
64 struct snd_kcontrol *kctl;
65
66 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
67 if (!cval)
68 return -ENOMEM;
69
70 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
71 cval->val_type = val_type;
72 cval->channels = 1;
73 cval->control = control;
74 cval->cmask = cmask;
75 cval->idx_off = idx_off;
76
77 /* get_min_max() is called only for integer volumes later,
78 * so provide a short-cut for booleans */
79 cval->min = 0;
80 cval->max = 1;
81 cval->res = 0;
82 cval->dBmin = 0;
83 cval->dBmax = 0;
84
85 /* Create control */
86 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
87 if (!kctl) {
88 kfree(cval);
89 return -ENOMEM;
90 }
91
92 /* Set name */
93 snprintf(kctl->id.name, sizeof(kctl->id.name), name);
94 kctl->private_free = snd_usb_mixer_elem_free;
95
96 /* set TLV */
97 if (tlv_callback) {
98 kctl->tlv.c = tlv_callback;
99 kctl->vd[0].access |=
100 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
101 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
102 }
103 /* Add control to mixer */
104 return snd_usb_mixer_add_control(&cval->head, kctl);
105}
106
107static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
108 unsigned int unitid,
109 unsigned int control,
110 unsigned int cmask,
111 int val_type,
112 const char *name,
113 snd_kcontrol_tlv_rw_t *tlv_callback)
114{
115 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
116 val_type, 0 /* Offset */, name, tlv_callback);
117}
118
119/*
120 * Create a set of standard UAC controls from a table
121 */
122static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
123 const struct std_mono_table *t)
124{
125 int err;
126
127 while (t->name != NULL) {
128 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
129 t->cmask, t->val_type, t->name, t->tlv_callback);
130 if (err < 0)
131 return err;
132 t++;
133 }
134
135 return 0;
136}
137
138static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer,
139 int id,
140 usb_mixer_elem_resume_func_t resume,
141 const struct snd_kcontrol_new *knew,
142 struct usb_mixer_elem_list **listp)
143{
144 struct usb_mixer_elem_list *list;
145 struct snd_kcontrol *kctl;
146
147 list = kzalloc(sizeof(*list), GFP_KERNEL);
148 if (!list)
149 return -ENOMEM;
150 if (listp)
151 *listp = list;
152 list->mixer = mixer;
153 list->id = id;
154 list->resume = resume;
155 kctl = snd_ctl_new1(knew, list);
156 if (!kctl) {
157 kfree(list);
158 return -ENOMEM;
159 }
160 kctl->private_free = snd_usb_mixer_elem_free;
161 /* don't use snd_usb_mixer_add_control() here, this is a special list element */
162 return snd_usb_mixer_add_list(list, kctl, false);
163}
164
165/*
166 * Sound Blaster remote control configuration
167 *
168 * format of remote control data:
169 * Extigy: xx 00
170 * Audigy 2 NX: 06 80 xx 00 00 00
171 * Live! 24-bit: 06 80 xx yy 22 83
172 */
173static const struct rc_config {
174 u32 usb_id;
175 u8 offset;
176 u8 length;
177 u8 packet_length;
178 u8 min_packet_length; /* minimum accepted length of the URB result */
179 u8 mute_mixer_id;
180 u32 mute_code;
181} rc_configs[] = {
182 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
183 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
184 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
185 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
186 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
187 { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
188 { USB_ID(0x041e, 0x3263), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
189 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
190};
191
192static void snd_usb_soundblaster_remote_complete(struct urb *urb)
193{
194 struct usb_mixer_interface *mixer = urb->context;
195 const struct rc_config *rc = mixer->rc_cfg;
196 u32 code;
197
198 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
199 return;
200
201 code = mixer->rc_buffer[rc->offset];
202 if (rc->length == 2)
203 code |= mixer->rc_buffer[rc->offset + 1] << 8;
204
205 /* the Mute button actually changes the mixer control */
206 if (code == rc->mute_code)
207 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
208 mixer->rc_code = code;
209 wmb();
210 wake_up(&mixer->rc_waitq);
211}
212
213static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
214 long count, loff_t *offset)
215{
216 struct usb_mixer_interface *mixer = hw->private_data;
217 int err;
218 u32 rc_code;
219
220 if (count != 1 && count != 4)
221 return -EINVAL;
222 err = wait_event_interruptible(mixer->rc_waitq,
223 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
224 if (err == 0) {
225 if (count == 1)
226 err = put_user(rc_code, buf);
227 else
228 err = put_user(rc_code, (u32 __user *)buf);
229 }
230 return err < 0 ? err : count;
231}
232
233static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
234 poll_table *wait)
235{
236 struct usb_mixer_interface *mixer = hw->private_data;
237
238 poll_wait(file, &mixer->rc_waitq, wait);
239 return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0;
240}
241
242static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
243{
244 struct snd_hwdep *hwdep;
245 int err, len, i;
246
247 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
248 if (rc_configs[i].usb_id == mixer->chip->usb_id)
249 break;
250 if (i >= ARRAY_SIZE(rc_configs))
251 return 0;
252 mixer->rc_cfg = &rc_configs[i];
253
254 len = mixer->rc_cfg->packet_length;
255
256 init_waitqueue_head(&mixer->rc_waitq);
257 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
258 if (err < 0)
259 return err;
260 snprintf(hwdep->name, sizeof(hwdep->name),
261 "%s remote control", mixer->chip->card->shortname);
262 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
263 hwdep->private_data = mixer;
264 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
265 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
266 hwdep->exclusive = 1;
267
268 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
269 if (!mixer->rc_urb)
270 return -ENOMEM;
271 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
272 if (!mixer->rc_setup_packet) {
273 usb_free_urb(mixer->rc_urb);
274 mixer->rc_urb = NULL;
275 return -ENOMEM;
276 }
277 mixer->rc_setup_packet->bRequestType =
278 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
279 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
280 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
281 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
282 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
283 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
284 usb_rcvctrlpipe(mixer->chip->dev, 0),
285 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
286 snd_usb_soundblaster_remote_complete, mixer);
287 return 0;
288}
289
290#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
291
292static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
293{
294 ucontrol->value.integer.value[0] = kcontrol->private_value >> 8;
295 return 0;
296}
297
298static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer,
299 int value, int index)
300{
301 struct snd_usb_audio *chip = mixer->chip;
302 int err;
303
304 err = snd_usb_lock_shutdown(chip);
305 if (err < 0)
306 return err;
307
308 if (chip->usb_id == USB_ID(0x041e, 0x3042))
309 err = snd_usb_ctl_msg(chip->dev,
310 usb_sndctrlpipe(chip->dev, 0), 0x24,
311 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
312 !value, 0, NULL, 0);
313 /* USB X-Fi S51 Pro */
314 if (chip->usb_id == USB_ID(0x041e, 0x30df))
315 err = snd_usb_ctl_msg(chip->dev,
316 usb_sndctrlpipe(chip->dev, 0), 0x24,
317 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
318 !value, 0, NULL, 0);
319 else
320 err = snd_usb_ctl_msg(chip->dev,
321 usb_sndctrlpipe(chip->dev, 0), 0x24,
322 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
323 value, index + 2, NULL, 0);
324 snd_usb_unlock_shutdown(chip);
325 return err;
326}
327
328static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol,
329 struct snd_ctl_elem_value *ucontrol)
330{
331 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
332 struct usb_mixer_interface *mixer = list->mixer;
333 int index = kcontrol->private_value & 0xff;
334 unsigned int value = ucontrol->value.integer.value[0];
335 int old_value = kcontrol->private_value >> 8;
336 int err;
337
338 if (value > 1)
339 return -EINVAL;
340 if (value == old_value)
341 return 0;
342 kcontrol->private_value = (value << 8) | index;
343 err = snd_audigy2nx_led_update(mixer, value, index);
344 return err < 0 ? err : 1;
345}
346
347static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list)
348{
349 int priv_value = list->kctl->private_value;
350
351 return snd_audigy2nx_led_update(list->mixer, priv_value >> 8,
352 priv_value & 0xff);
353}
354
355/* name and private_value are set dynamically */
356static const struct snd_kcontrol_new snd_audigy2nx_control = {
357 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
358 .info = snd_audigy2nx_led_info,
359 .get = snd_audigy2nx_led_get,
360 .put = snd_audigy2nx_led_put,
361};
362
363static const char * const snd_audigy2nx_led_names[] = {
364 "CMSS LED Switch",
365 "Power LED Switch",
366 "Dolby Digital LED Switch",
367};
368
369static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
370{
371 int i, err;
372
373 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) {
374 struct snd_kcontrol_new knew;
375
376 /* USB X-Fi S51 doesn't have a CMSS LED */
377 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
378 continue;
379 /* USB X-Fi S51 Pro doesn't have one either */
380 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
381 continue;
382 if (i > 1 && /* Live24ext has 2 LEDs only */
383 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
384 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
385 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
386 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
387 break;
388
389 knew = snd_audigy2nx_control;
390 knew.name = snd_audigy2nx_led_names[i];
391 knew.private_value = (1 << 8) | i; /* LED on as default */
392 err = add_single_ctl_with_resume(mixer, 0,
393 snd_audigy2nx_led_resume,
394 &knew, NULL);
395 if (err < 0)
396 return err;
397 }
398 return 0;
399}
400
401static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
402 struct snd_info_buffer *buffer)
403{
404 static const struct sb_jack {
405 int unitid;
406 const char *name;
407 } jacks_audigy2nx[] = {
408 {4, "dig in "},
409 {7, "line in"},
410 {19, "spk out"},
411 {20, "hph out"},
412 {-1, NULL}
413 }, jacks_live24ext[] = {
414 {4, "line in"}, /* &1=Line, &2=Mic*/
415 {3, "hph out"}, /* headphones */
416 {0, "RC "}, /* last command, 6 bytes see rc_config above */
417 {-1, NULL}
418 };
419 const struct sb_jack *jacks;
420 struct usb_mixer_interface *mixer = entry->private_data;
421 int i, err;
422 u8 buf[3];
423
424 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
425 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
426 jacks = jacks_audigy2nx;
427 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
428 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
429 jacks = jacks_live24ext;
430 else
431 return;
432
433 for (i = 0; jacks[i].name; ++i) {
434 snd_iprintf(buffer, "%s: ", jacks[i].name);
435 err = snd_usb_lock_shutdown(mixer->chip);
436 if (err < 0)
437 return;
438 err = snd_usb_ctl_msg(mixer->chip->dev,
439 usb_rcvctrlpipe(mixer->chip->dev, 0),
440 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
441 USB_RECIP_INTERFACE, 0,
442 jacks[i].unitid << 8, buf, 3);
443 snd_usb_unlock_shutdown(mixer->chip);
444 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
445 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
446 else
447 snd_iprintf(buffer, "?\n");
448 }
449}
450
451/* EMU0204 */
452static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
453 struct snd_ctl_elem_info *uinfo)
454{
455 static const char * const texts[2] = {"1/2", "3/4"};
456
457 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
458}
459
460static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
461 struct snd_ctl_elem_value *ucontrol)
462{
463 ucontrol->value.enumerated.item[0] = kcontrol->private_value;
464 return 0;
465}
466
467static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer,
468 int value)
469{
470 struct snd_usb_audio *chip = mixer->chip;
471 int err;
472 unsigned char buf[2];
473
474 err = snd_usb_lock_shutdown(chip);
475 if (err < 0)
476 return err;
477
478 buf[0] = 0x01;
479 buf[1] = value ? 0x02 : 0x01;
480 err = snd_usb_ctl_msg(chip->dev,
481 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
482 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
483 0x0400, 0x0e00, buf, 2);
484 snd_usb_unlock_shutdown(chip);
485 return err;
486}
487
488static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
489 struct snd_ctl_elem_value *ucontrol)
490{
491 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
492 struct usb_mixer_interface *mixer = list->mixer;
493 unsigned int value = ucontrol->value.enumerated.item[0];
494 int err;
495
496 if (value > 1)
497 return -EINVAL;
498
499 if (value == kcontrol->private_value)
500 return 0;
501
502 kcontrol->private_value = value;
503 err = snd_emu0204_ch_switch_update(mixer, value);
504 return err < 0 ? err : 1;
505}
506
507static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list)
508{
509 return snd_emu0204_ch_switch_update(list->mixer,
510 list->kctl->private_value);
511}
512
513static const struct snd_kcontrol_new snd_emu0204_control = {
514 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
515 .name = "Front Jack Channels",
516 .info = snd_emu0204_ch_switch_info,
517 .get = snd_emu0204_ch_switch_get,
518 .put = snd_emu0204_ch_switch_put,
519 .private_value = 0,
520};
521
522static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
523{
524 return add_single_ctl_with_resume(mixer, 0,
525 snd_emu0204_ch_switch_resume,
526 &snd_emu0204_control, NULL);
527}
528
529/* ASUS Xonar U1 / U3 controls */
530
531static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
532 struct snd_ctl_elem_value *ucontrol)
533{
534 ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02);
535 return 0;
536}
537
538static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer,
539 unsigned char status)
540{
541 struct snd_usb_audio *chip = mixer->chip;
542 int err;
543
544 err = snd_usb_lock_shutdown(chip);
545 if (err < 0)
546 return err;
547 err = snd_usb_ctl_msg(chip->dev,
548 usb_sndctrlpipe(chip->dev, 0), 0x08,
549 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
550 50, 0, &status, 1);
551 snd_usb_unlock_shutdown(chip);
552 return err;
553}
554
555static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
556 struct snd_ctl_elem_value *ucontrol)
557{
558 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
559 u8 old_status, new_status;
560 int err;
561
562 old_status = kcontrol->private_value;
563 if (ucontrol->value.integer.value[0])
564 new_status = old_status | 0x02;
565 else
566 new_status = old_status & ~0x02;
567 if (new_status == old_status)
568 return 0;
569
570 kcontrol->private_value = new_status;
571 err = snd_xonar_u1_switch_update(list->mixer, new_status);
572 return err < 0 ? err : 1;
573}
574
575static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list)
576{
577 return snd_xonar_u1_switch_update(list->mixer,
578 list->kctl->private_value);
579}
580
581static const struct snd_kcontrol_new snd_xonar_u1_output_switch = {
582 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
583 .name = "Digital Playback Switch",
584 .info = snd_ctl_boolean_mono_info,
585 .get = snd_xonar_u1_switch_get,
586 .put = snd_xonar_u1_switch_put,
587 .private_value = 0x05,
588};
589
590static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
591{
592 return add_single_ctl_with_resume(mixer, 0,
593 snd_xonar_u1_switch_resume,
594 &snd_xonar_u1_output_switch, NULL);
595}
596
597/* Digidesign Mbox 1 clock source switch (internal/spdif) */
598
599static int snd_mbox1_switch_get(struct snd_kcontrol *kctl,
600 struct snd_ctl_elem_value *ucontrol)
601{
602 ucontrol->value.enumerated.item[0] = kctl->private_value;
603 return 0;
604}
605
606static int snd_mbox1_switch_update(struct usb_mixer_interface *mixer, int val)
607{
608 struct snd_usb_audio *chip = mixer->chip;
609 int err;
610 unsigned char buff[3];
611
612 err = snd_usb_lock_shutdown(chip);
613 if (err < 0)
614 return err;
615
616 /* Prepare for magic command to toggle clock source */
617 err = snd_usb_ctl_msg(chip->dev,
618 usb_rcvctrlpipe(chip->dev, 0), 0x81,
619 USB_DIR_IN |
620 USB_TYPE_CLASS |
621 USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1);
622 if (err < 0)
623 goto err;
624 err = snd_usb_ctl_msg(chip->dev,
625 usb_rcvctrlpipe(chip->dev, 0), 0x81,
626 USB_DIR_IN |
627 USB_TYPE_CLASS |
628 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
629 if (err < 0)
630 goto err;
631
632 /* 2 possibilities: Internal -> send sample rate
633 * S/PDIF sync -> send zeroes
634 * NB: Sample rate locked to 48kHz on purpose to
635 * prevent user from resetting the sample rate
636 * while S/PDIF sync is enabled and confusing
637 * this configuration.
638 */
639 if (val == 0) {
640 buff[0] = 0x80;
641 buff[1] = 0xbb;
642 buff[2] = 0x00;
643 } else {
644 buff[0] = buff[1] = buff[2] = 0x00;
645 }
646
647 /* Send the magic command to toggle the clock source */
648 err = snd_usb_ctl_msg(chip->dev,
649 usb_sndctrlpipe(chip->dev, 0), 0x1,
650 USB_TYPE_CLASS |
651 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
652 if (err < 0)
653 goto err;
654 err = snd_usb_ctl_msg(chip->dev,
655 usb_rcvctrlpipe(chip->dev, 0), 0x81,
656 USB_DIR_IN |
657 USB_TYPE_CLASS |
658 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
659 if (err < 0)
660 goto err;
661 err = snd_usb_ctl_msg(chip->dev,
662 usb_rcvctrlpipe(chip->dev, 0), 0x81,
663 USB_DIR_IN |
664 USB_TYPE_CLASS |
665 USB_RECIP_ENDPOINT, 0x100, 0x2, buff, 3);
666 if (err < 0)
667 goto err;
668
669err:
670 snd_usb_unlock_shutdown(chip);
671 return err;
672}
673
674static int snd_mbox1_switch_put(struct snd_kcontrol *kctl,
675 struct snd_ctl_elem_value *ucontrol)
676{
677 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
678 struct usb_mixer_interface *mixer = list->mixer;
679 int err;
680 bool cur_val, new_val;
681
682 cur_val = kctl->private_value;
683 new_val = ucontrol->value.enumerated.item[0];
684 if (cur_val == new_val)
685 return 0;
686
687 kctl->private_value = new_val;
688 err = snd_mbox1_switch_update(mixer, new_val);
689 return err < 0 ? err : 1;
690}
691
692static int snd_mbox1_switch_info(struct snd_kcontrol *kcontrol,
693 struct snd_ctl_elem_info *uinfo)
694{
695 static const char *const texts[2] = {
696 "Internal",
697 "S/PDIF"
698 };
699
700 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
701}
702
703static int snd_mbox1_switch_resume(struct usb_mixer_elem_list *list)
704{
705 return snd_mbox1_switch_update(list->mixer, list->kctl->private_value);
706}
707
708static const struct snd_kcontrol_new snd_mbox1_switch = {
709 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
710 .name = "Clock Source",
711 .index = 0,
712 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
713 .info = snd_mbox1_switch_info,
714 .get = snd_mbox1_switch_get,
715 .put = snd_mbox1_switch_put,
716 .private_value = 0
717};
718
719static int snd_mbox1_create_sync_switch(struct usb_mixer_interface *mixer)
720{
721 return add_single_ctl_with_resume(mixer, 0,
722 snd_mbox1_switch_resume,
723 &snd_mbox1_switch, NULL);
724}
725
726/* Native Instruments device quirks */
727
728#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
729
730static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
731 struct snd_kcontrol *kctl)
732{
733 struct usb_device *dev = mixer->chip->dev;
734 unsigned int pval = kctl->private_value;
735 u8 value;
736 int err;
737
738 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
739 (pval >> 16) & 0xff,
740 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
741 0, pval & 0xffff, &value, 1);
742 if (err < 0) {
743 dev_err(&dev->dev,
744 "unable to issue vendor read request (ret = %d)", err);
745 return err;
746 }
747
748 kctl->private_value |= ((unsigned int)value << 24);
749 return 0;
750}
751
752static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
753 struct snd_ctl_elem_value *ucontrol)
754{
755 ucontrol->value.integer.value[0] = kcontrol->private_value >> 24;
756 return 0;
757}
758
759static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list)
760{
761 struct snd_usb_audio *chip = list->mixer->chip;
762 unsigned int pval = list->kctl->private_value;
763 int err;
764
765 err = snd_usb_lock_shutdown(chip);
766 if (err < 0)
767 return err;
768 err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
769 (pval >> 16) & 0xff,
770 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
771 pval >> 24, pval & 0xffff, NULL, 0, 1000);
772 snd_usb_unlock_shutdown(chip);
773 return err;
774}
775
776static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
777 struct snd_ctl_elem_value *ucontrol)
778{
779 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
780 u8 oldval = (kcontrol->private_value >> 24) & 0xff;
781 u8 newval = ucontrol->value.integer.value[0];
782 int err;
783
784 if (oldval == newval)
785 return 0;
786
787 kcontrol->private_value &= ~(0xff << 24);
788 kcontrol->private_value |= (unsigned int)newval << 24;
789 err = snd_ni_update_cur_val(list);
790 return err < 0 ? err : 1;
791}
792
793static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
794 {
795 .name = "Direct Thru Channel A",
796 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
797 },
798 {
799 .name = "Direct Thru Channel B",
800 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
801 },
802 {
803 .name = "Phono Input Channel A",
804 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
805 },
806 {
807 .name = "Phono Input Channel B",
808 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
809 },
810};
811
812static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
813 {
814 .name = "Direct Thru Channel A",
815 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
816 },
817 {
818 .name = "Direct Thru Channel B",
819 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
820 },
821 {
822 .name = "Direct Thru Channel C",
823 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
824 },
825 {
826 .name = "Direct Thru Channel D",
827 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
828 },
829 {
830 .name = "Phono Input Channel A",
831 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
832 },
833 {
834 .name = "Phono Input Channel B",
835 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
836 },
837 {
838 .name = "Phono Input Channel C",
839 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
840 },
841 {
842 .name = "Phono Input Channel D",
843 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
844 },
845};
846
847static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
848 const struct snd_kcontrol_new *kc,
849 unsigned int count)
850{
851 int i, err = 0;
852 struct snd_kcontrol_new template = {
853 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
854 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
855 .get = snd_nativeinstruments_control_get,
856 .put = snd_nativeinstruments_control_put,
857 .info = snd_ctl_boolean_mono_info,
858 };
859
860 for (i = 0; i < count; i++) {
861 struct usb_mixer_elem_list *list;
862
863 template.name = kc[i].name;
864 template.private_value = kc[i].private_value;
865
866 err = add_single_ctl_with_resume(mixer, 0,
867 snd_ni_update_cur_val,
868 &template, &list);
869 if (err < 0)
870 break;
871 snd_ni_control_init_val(mixer, list->kctl);
872 }
873
874 return err;
875}
876
877/* M-Audio FastTrack Ultra quirks */
878/* FTU Effect switch (also used by C400/C600) */
879static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
880 struct snd_ctl_elem_info *uinfo)
881{
882 static const char *const texts[8] = {
883 "Room 1", "Room 2", "Room 3", "Hall 1",
884 "Hall 2", "Plate", "Delay", "Echo"
885 };
886
887 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
888}
889
890static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
891 struct snd_kcontrol *kctl)
892{
893 struct usb_device *dev = mixer->chip->dev;
894 unsigned int pval = kctl->private_value;
895 int err;
896 unsigned char value[2];
897
898 value[0] = 0x00;
899 value[1] = 0x00;
900
901 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
902 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
903 pval & 0xff00,
904 snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8),
905 value, 2);
906 if (err < 0)
907 return err;
908
909 kctl->private_value |= (unsigned int)value[0] << 24;
910 return 0;
911}
912
913static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
914 struct snd_ctl_elem_value *ucontrol)
915{
916 ucontrol->value.enumerated.item[0] = kctl->private_value >> 24;
917 return 0;
918}
919
920static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list)
921{
922 struct snd_usb_audio *chip = list->mixer->chip;
923 unsigned int pval = list->kctl->private_value;
924 unsigned char value[2];
925 int err;
926
927 value[0] = pval >> 24;
928 value[1] = 0;
929
930 err = snd_usb_lock_shutdown(chip);
931 if (err < 0)
932 return err;
933 err = snd_usb_ctl_msg(chip->dev,
934 usb_sndctrlpipe(chip->dev, 0),
935 UAC_SET_CUR,
936 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
937 pval & 0xff00,
938 snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8),
939 value, 2);
940 snd_usb_unlock_shutdown(chip);
941 return err;
942}
943
944static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
945 struct snd_ctl_elem_value *ucontrol)
946{
947 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
948 unsigned int pval = list->kctl->private_value;
949 int cur_val, err, new_val;
950
951 cur_val = pval >> 24;
952 new_val = ucontrol->value.enumerated.item[0];
953 if (cur_val == new_val)
954 return 0;
955
956 kctl->private_value &= ~(0xff << 24);
957 kctl->private_value |= new_val << 24;
958 err = snd_ftu_eff_switch_update(list);
959 return err < 0 ? err : 1;
960}
961
962static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
963 int validx, int bUnitID)
964{
965 static struct snd_kcontrol_new template = {
966 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
967 .name = "Effect Program Switch",
968 .index = 0,
969 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
970 .info = snd_ftu_eff_switch_info,
971 .get = snd_ftu_eff_switch_get,
972 .put = snd_ftu_eff_switch_put
973 };
974 struct usb_mixer_elem_list *list;
975 int err;
976
977 err = add_single_ctl_with_resume(mixer, bUnitID,
978 snd_ftu_eff_switch_update,
979 &template, &list);
980 if (err < 0)
981 return err;
982 list->kctl->private_value = (validx << 8) | bUnitID;
983 snd_ftu_eff_switch_init(mixer, list->kctl);
984 return 0;
985}
986
987/* Create volume controls for FTU devices*/
988static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
989{
990 char name[64];
991 unsigned int control, cmask;
992 int in, out, err;
993
994 const unsigned int id = 5;
995 const int val_type = USB_MIXER_S16;
996
997 for (out = 0; out < 8; out++) {
998 control = out + 1;
999 for (in = 0; in < 8; in++) {
1000 cmask = 1 << in;
1001 snprintf(name, sizeof(name),
1002 "AIn%d - Out%d Capture Volume",
1003 in + 1, out + 1);
1004 err = snd_create_std_mono_ctl(mixer, id, control,
1005 cmask, val_type, name,
1006 &snd_usb_mixer_vol_tlv);
1007 if (err < 0)
1008 return err;
1009 }
1010 for (in = 8; in < 16; in++) {
1011 cmask = 1 << in;
1012 snprintf(name, sizeof(name),
1013 "DIn%d - Out%d Playback Volume",
1014 in - 7, out + 1);
1015 err = snd_create_std_mono_ctl(mixer, id, control,
1016 cmask, val_type, name,
1017 &snd_usb_mixer_vol_tlv);
1018 if (err < 0)
1019 return err;
1020 }
1021 }
1022
1023 return 0;
1024}
1025
1026/* This control needs a volume quirk, see mixer.c */
1027static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1028{
1029 static const char name[] = "Effect Volume";
1030 const unsigned int id = 6;
1031 const int val_type = USB_MIXER_U8;
1032 const unsigned int control = 2;
1033 const unsigned int cmask = 0;
1034
1035 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1036 name, snd_usb_mixer_vol_tlv);
1037}
1038
1039/* This control needs a volume quirk, see mixer.c */
1040static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1041{
1042 static const char name[] = "Effect Duration";
1043 const unsigned int id = 6;
1044 const int val_type = USB_MIXER_S16;
1045 const unsigned int control = 3;
1046 const unsigned int cmask = 0;
1047
1048 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1049 name, snd_usb_mixer_vol_tlv);
1050}
1051
1052/* This control needs a volume quirk, see mixer.c */
1053static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1054{
1055 static const char name[] = "Effect Feedback Volume";
1056 const unsigned int id = 6;
1057 const int val_type = USB_MIXER_U8;
1058 const unsigned int control = 4;
1059 const unsigned int cmask = 0;
1060
1061 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1062 name, NULL);
1063}
1064
1065static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1066{
1067 unsigned int cmask;
1068 int err, ch;
1069 char name[48];
1070
1071 const unsigned int id = 7;
1072 const int val_type = USB_MIXER_S16;
1073 const unsigned int control = 7;
1074
1075 for (ch = 0; ch < 4; ++ch) {
1076 cmask = 1 << ch;
1077 snprintf(name, sizeof(name),
1078 "Effect Return %d Volume", ch + 1);
1079 err = snd_create_std_mono_ctl(mixer, id, control,
1080 cmask, val_type, name,
1081 snd_usb_mixer_vol_tlv);
1082 if (err < 0)
1083 return err;
1084 }
1085
1086 return 0;
1087}
1088
1089static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1090{
1091 unsigned int cmask;
1092 int err, ch;
1093 char name[48];
1094
1095 const unsigned int id = 5;
1096 const int val_type = USB_MIXER_S16;
1097 const unsigned int control = 9;
1098
1099 for (ch = 0; ch < 8; ++ch) {
1100 cmask = 1 << ch;
1101 snprintf(name, sizeof(name),
1102 "Effect Send AIn%d Volume", ch + 1);
1103 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1104 val_type, name,
1105 snd_usb_mixer_vol_tlv);
1106 if (err < 0)
1107 return err;
1108 }
1109 for (ch = 8; ch < 16; ++ch) {
1110 cmask = 1 << ch;
1111 snprintf(name, sizeof(name),
1112 "Effect Send DIn%d Volume", ch - 7);
1113 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1114 val_type, name,
1115 snd_usb_mixer_vol_tlv);
1116 if (err < 0)
1117 return err;
1118 }
1119 return 0;
1120}
1121
1122static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1123{
1124 int err;
1125
1126 err = snd_ftu_create_volume_ctls(mixer);
1127 if (err < 0)
1128 return err;
1129
1130 err = snd_ftu_create_effect_switch(mixer, 1, 6);
1131 if (err < 0)
1132 return err;
1133
1134 err = snd_ftu_create_effect_volume_ctl(mixer);
1135 if (err < 0)
1136 return err;
1137
1138 err = snd_ftu_create_effect_duration_ctl(mixer);
1139 if (err < 0)
1140 return err;
1141
1142 err = snd_ftu_create_effect_feedback_ctl(mixer);
1143 if (err < 0)
1144 return err;
1145
1146 err = snd_ftu_create_effect_return_ctls(mixer);
1147 if (err < 0)
1148 return err;
1149
1150 err = snd_ftu_create_effect_send_ctls(mixer);
1151 if (err < 0)
1152 return err;
1153
1154 return 0;
1155}
1156
1157void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1158 unsigned char samplerate_id)
1159{
1160 struct usb_mixer_interface *mixer;
1161 struct usb_mixer_elem_info *cval;
1162 int unitid = 12; /* SampleRate ExtensionUnit ID */
1163
1164 list_for_each_entry(mixer, &chip->mixer_list, list) {
1165 if (mixer->id_elems[unitid]) {
1166 cval = mixer_elem_list_to_info(mixer->id_elems[unitid]);
1167 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1168 cval->control << 8,
1169 samplerate_id);
1170 snd_usb_mixer_notify_id(mixer, unitid);
1171 break;
1172 }
1173 }
1174}
1175
1176/* M-Audio Fast Track C400/C600 */
1177/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1178static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1179{
1180 char name[64];
1181 unsigned int cmask, offset;
1182 int out, chan, err;
1183 int num_outs = 0;
1184 int num_ins = 0;
1185
1186 const unsigned int id = 0x40;
1187 const int val_type = USB_MIXER_S16;
1188 const int control = 1;
1189
1190 switch (mixer->chip->usb_id) {
1191 case USB_ID(0x0763, 0x2030):
1192 num_outs = 6;
1193 num_ins = 4;
1194 break;
1195 case USB_ID(0x0763, 0x2031):
1196 num_outs = 8;
1197 num_ins = 6;
1198 break;
1199 }
1200
1201 for (chan = 0; chan < num_outs + num_ins; chan++) {
1202 for (out = 0; out < num_outs; out++) {
1203 if (chan < num_outs) {
1204 snprintf(name, sizeof(name),
1205 "PCM%d-Out%d Playback Volume",
1206 chan + 1, out + 1);
1207 } else {
1208 snprintf(name, sizeof(name),
1209 "In%d-Out%d Playback Volume",
1210 chan - num_outs + 1, out + 1);
1211 }
1212
1213 cmask = (out == 0) ? 0 : 1 << (out - 1);
1214 offset = chan * num_outs;
1215 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1216 cmask, val_type, offset, name,
1217 &snd_usb_mixer_vol_tlv);
1218 if (err < 0)
1219 return err;
1220 }
1221 }
1222
1223 return 0;
1224}
1225
1226/* This control needs a volume quirk, see mixer.c */
1227static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1228{
1229 static const char name[] = "Effect Volume";
1230 const unsigned int id = 0x43;
1231 const int val_type = USB_MIXER_U8;
1232 const unsigned int control = 3;
1233 const unsigned int cmask = 0;
1234
1235 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1236 name, snd_usb_mixer_vol_tlv);
1237}
1238
1239/* This control needs a volume quirk, see mixer.c */
1240static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1241{
1242 static const char name[] = "Effect Duration";
1243 const unsigned int id = 0x43;
1244 const int val_type = USB_MIXER_S16;
1245 const unsigned int control = 4;
1246 const unsigned int cmask = 0;
1247
1248 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1249 name, snd_usb_mixer_vol_tlv);
1250}
1251
1252/* This control needs a volume quirk, see mixer.c */
1253static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1254{
1255 static const char name[] = "Effect Feedback Volume";
1256 const unsigned int id = 0x43;
1257 const int val_type = USB_MIXER_U8;
1258 const unsigned int control = 5;
1259 const unsigned int cmask = 0;
1260
1261 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1262 name, NULL);
1263}
1264
1265static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1266{
1267 char name[64];
1268 unsigned int cmask;
1269 int chan, err;
1270 int num_outs = 0;
1271 int num_ins = 0;
1272
1273 const unsigned int id = 0x42;
1274 const int val_type = USB_MIXER_S16;
1275 const int control = 1;
1276
1277 switch (mixer->chip->usb_id) {
1278 case USB_ID(0x0763, 0x2030):
1279 num_outs = 6;
1280 num_ins = 4;
1281 break;
1282 case USB_ID(0x0763, 0x2031):
1283 num_outs = 8;
1284 num_ins = 6;
1285 break;
1286 }
1287
1288 for (chan = 0; chan < num_outs + num_ins; chan++) {
1289 if (chan < num_outs) {
1290 snprintf(name, sizeof(name),
1291 "Effect Send DOut%d",
1292 chan + 1);
1293 } else {
1294 snprintf(name, sizeof(name),
1295 "Effect Send AIn%d",
1296 chan - num_outs + 1);
1297 }
1298
1299 cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1300 err = snd_create_std_mono_ctl(mixer, id, control,
1301 cmask, val_type, name,
1302 &snd_usb_mixer_vol_tlv);
1303 if (err < 0)
1304 return err;
1305 }
1306
1307 return 0;
1308}
1309
1310static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1311{
1312 char name[64];
1313 unsigned int cmask;
1314 int chan, err;
1315 int num_outs = 0;
1316 int offset = 0;
1317
1318 const unsigned int id = 0x40;
1319 const int val_type = USB_MIXER_S16;
1320 const int control = 1;
1321
1322 switch (mixer->chip->usb_id) {
1323 case USB_ID(0x0763, 0x2030):
1324 num_outs = 6;
1325 offset = 0x3c;
1326 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1327 break;
1328 case USB_ID(0x0763, 0x2031):
1329 num_outs = 8;
1330 offset = 0x70;
1331 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1332 break;
1333 }
1334
1335 for (chan = 0; chan < num_outs; chan++) {
1336 snprintf(name, sizeof(name),
1337 "Effect Return %d",
1338 chan + 1);
1339
1340 cmask = (chan == 0) ? 0 :
1341 1 << (chan + (chan % 2) * num_outs - 1);
1342 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1343 cmask, val_type, offset, name,
1344 &snd_usb_mixer_vol_tlv);
1345 if (err < 0)
1346 return err;
1347 }
1348
1349 return 0;
1350}
1351
1352static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1353{
1354 int err;
1355
1356 err = snd_c400_create_vol_ctls(mixer);
1357 if (err < 0)
1358 return err;
1359
1360 err = snd_c400_create_effect_vol_ctls(mixer);
1361 if (err < 0)
1362 return err;
1363
1364 err = snd_c400_create_effect_ret_vol_ctls(mixer);
1365 if (err < 0)
1366 return err;
1367
1368 err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1369 if (err < 0)
1370 return err;
1371
1372 err = snd_c400_create_effect_volume_ctl(mixer);
1373 if (err < 0)
1374 return err;
1375
1376 err = snd_c400_create_effect_duration_ctl(mixer);
1377 if (err < 0)
1378 return err;
1379
1380 err = snd_c400_create_effect_feedback_ctl(mixer);
1381 if (err < 0)
1382 return err;
1383
1384 return 0;
1385}
1386
1387/*
1388 * The mixer units for Ebox-44 are corrupt, and even where they
1389 * are valid they presents mono controls as L and R channels of
1390 * stereo. So we provide a good mixer here.
1391 */
1392static const struct std_mono_table ebox44_table[] = {
1393 {
1394 .unitid = 4,
1395 .control = 1,
1396 .cmask = 0x0,
1397 .val_type = USB_MIXER_INV_BOOLEAN,
1398 .name = "Headphone Playback Switch"
1399 },
1400 {
1401 .unitid = 4,
1402 .control = 2,
1403 .cmask = 0x1,
1404 .val_type = USB_MIXER_S16,
1405 .name = "Headphone A Mix Playback Volume"
1406 },
1407 {
1408 .unitid = 4,
1409 .control = 2,
1410 .cmask = 0x2,
1411 .val_type = USB_MIXER_S16,
1412 .name = "Headphone B Mix Playback Volume"
1413 },
1414
1415 {
1416 .unitid = 7,
1417 .control = 1,
1418 .cmask = 0x0,
1419 .val_type = USB_MIXER_INV_BOOLEAN,
1420 .name = "Output Playback Switch"
1421 },
1422 {
1423 .unitid = 7,
1424 .control = 2,
1425 .cmask = 0x1,
1426 .val_type = USB_MIXER_S16,
1427 .name = "Output A Playback Volume"
1428 },
1429 {
1430 .unitid = 7,
1431 .control = 2,
1432 .cmask = 0x2,
1433 .val_type = USB_MIXER_S16,
1434 .name = "Output B Playback Volume"
1435 },
1436
1437 {
1438 .unitid = 10,
1439 .control = 1,
1440 .cmask = 0x0,
1441 .val_type = USB_MIXER_INV_BOOLEAN,
1442 .name = "Input Capture Switch"
1443 },
1444 {
1445 .unitid = 10,
1446 .control = 2,
1447 .cmask = 0x1,
1448 .val_type = USB_MIXER_S16,
1449 .name = "Input A Capture Volume"
1450 },
1451 {
1452 .unitid = 10,
1453 .control = 2,
1454 .cmask = 0x2,
1455 .val_type = USB_MIXER_S16,
1456 .name = "Input B Capture Volume"
1457 },
1458
1459 {}
1460};
1461
1462/* Audio Advantage Micro II findings:
1463 *
1464 * Mapping spdif AES bits to vendor register.bit:
1465 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1466 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1467 * AES2: [0 0 0 0 0 0 0 0]
1468 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1469 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1470 *
1471 * power on values:
1472 * r2: 0x10
1473 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1474 * just after it to 0xa0, presumably it disables/mutes some analog
1475 * parts when there is no audio.)
1476 * r9: 0x28
1477 *
1478 * Optical transmitter on/off:
1479 * vendor register.bit: 9.1
1480 * 0 - on (0x28 register value)
1481 * 1 - off (0x2a register value)
1482 *
1483 */
1484static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1485 struct snd_ctl_elem_info *uinfo)
1486{
1487 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1488 uinfo->count = 1;
1489 return 0;
1490}
1491
1492static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1493 struct snd_ctl_elem_value *ucontrol)
1494{
1495 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1496 struct snd_usb_audio *chip = list->mixer->chip;
1497 int err;
1498 struct usb_interface *iface;
1499 struct usb_host_interface *alts;
1500 unsigned int ep;
1501 unsigned char data[3];
1502 int rate;
1503
1504 err = snd_usb_lock_shutdown(chip);
1505 if (err < 0)
1506 return err;
1507
1508 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1509 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1510 ucontrol->value.iec958.status[2] = 0x00;
1511
1512 /* use known values for that card: interface#1 altsetting#1 */
1513 iface = usb_ifnum_to_if(chip->dev, 1);
1514 if (!iface || iface->num_altsetting < 2) {
1515 err = -EINVAL;
1516 goto end;
1517 }
1518 alts = &iface->altsetting[1];
1519 if (get_iface_desc(alts)->bNumEndpoints < 1) {
1520 err = -EINVAL;
1521 goto end;
1522 }
1523 ep = get_endpoint(alts, 0)->bEndpointAddress;
1524
1525 err = snd_usb_ctl_msg(chip->dev,
1526 usb_rcvctrlpipe(chip->dev, 0),
1527 UAC_GET_CUR,
1528 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1529 UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1530 ep,
1531 data,
1532 sizeof(data));
1533 if (err < 0)
1534 goto end;
1535
1536 rate = data[0] | (data[1] << 8) | (data[2] << 16);
1537 ucontrol->value.iec958.status[3] = (rate == 48000) ?
1538 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1539
1540 err = 0;
1541 end:
1542 snd_usb_unlock_shutdown(chip);
1543 return err;
1544}
1545
1546static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list)
1547{
1548 struct snd_usb_audio *chip = list->mixer->chip;
1549 unsigned int pval = list->kctl->private_value;
1550 u8 reg;
1551 int err;
1552
1553 err = snd_usb_lock_shutdown(chip);
1554 if (err < 0)
1555 return err;
1556
1557 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f);
1558 err = snd_usb_ctl_msg(chip->dev,
1559 usb_sndctrlpipe(chip->dev, 0),
1560 UAC_SET_CUR,
1561 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1562 reg,
1563 2,
1564 NULL,
1565 0);
1566 if (err < 0)
1567 goto end;
1568
1569 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20;
1570 reg |= (pval >> 12) & 0x0f;
1571 err = snd_usb_ctl_msg(chip->dev,
1572 usb_sndctrlpipe(chip->dev, 0),
1573 UAC_SET_CUR,
1574 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1575 reg,
1576 3,
1577 NULL,
1578 0);
1579 if (err < 0)
1580 goto end;
1581
1582 end:
1583 snd_usb_unlock_shutdown(chip);
1584 return err;
1585}
1586
1587static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1588 struct snd_ctl_elem_value *ucontrol)
1589{
1590 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1591 unsigned int pval, pval_old;
1592 int err;
1593
1594 pval = pval_old = kcontrol->private_value;
1595 pval &= 0xfffff0f0;
1596 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1597 pval |= (ucontrol->value.iec958.status[0] & 0x0f);
1598
1599 pval &= 0xffff0fff;
1600 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1601
1602 /* The frequency bits in AES3 cannot be set via register access. */
1603
1604 /* Silently ignore any bits from the request that cannot be set. */
1605
1606 if (pval == pval_old)
1607 return 0;
1608
1609 kcontrol->private_value = pval;
1610 err = snd_microii_spdif_default_update(list);
1611 return err < 0 ? err : 1;
1612}
1613
1614static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1615 struct snd_ctl_elem_value *ucontrol)
1616{
1617 ucontrol->value.iec958.status[0] = 0x0f;
1618 ucontrol->value.iec958.status[1] = 0xff;
1619 ucontrol->value.iec958.status[2] = 0x00;
1620 ucontrol->value.iec958.status[3] = 0x00;
1621
1622 return 0;
1623}
1624
1625static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1626 struct snd_ctl_elem_value *ucontrol)
1627{
1628 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1629
1630 return 0;
1631}
1632
1633static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list)
1634{
1635 struct snd_usb_audio *chip = list->mixer->chip;
1636 u8 reg = list->kctl->private_value;
1637 int err;
1638
1639 err = snd_usb_lock_shutdown(chip);
1640 if (err < 0)
1641 return err;
1642
1643 err = snd_usb_ctl_msg(chip->dev,
1644 usb_sndctrlpipe(chip->dev, 0),
1645 UAC_SET_CUR,
1646 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1647 reg,
1648 9,
1649 NULL,
1650 0);
1651
1652 snd_usb_unlock_shutdown(chip);
1653 return err;
1654}
1655
1656static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1657 struct snd_ctl_elem_value *ucontrol)
1658{
1659 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1660 u8 reg;
1661 int err;
1662
1663 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1664 if (reg != list->kctl->private_value)
1665 return 0;
1666
1667 kcontrol->private_value = reg;
1668 err = snd_microii_spdif_switch_update(list);
1669 return err < 0 ? err : 1;
1670}
1671
1672static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1673 {
1674 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1675 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1676 .info = snd_microii_spdif_info,
1677 .get = snd_microii_spdif_default_get,
1678 .put = snd_microii_spdif_default_put,
1679 .private_value = 0x00000100UL,/* reset value */
1680 },
1681 {
1682 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1683 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1684 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1685 .info = snd_microii_spdif_info,
1686 .get = snd_microii_spdif_mask_get,
1687 },
1688 {
1689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1690 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1691 .info = snd_ctl_boolean_mono_info,
1692 .get = snd_microii_spdif_switch_get,
1693 .put = snd_microii_spdif_switch_put,
1694 .private_value = 0x00000028UL,/* reset value */
1695 }
1696};
1697
1698static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1699{
1700 int err, i;
1701 static const usb_mixer_elem_resume_func_t resume_funcs[] = {
1702 snd_microii_spdif_default_update,
1703 NULL,
1704 snd_microii_spdif_switch_update
1705 };
1706
1707 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1708 err = add_single_ctl_with_resume(mixer, 0,
1709 resume_funcs[i],
1710 &snd_microii_mixer_spdif[i],
1711 NULL);
1712 if (err < 0)
1713 return err;
1714 }
1715
1716 return 0;
1717}
1718
1719/* Creative Sound Blaster E1 */
1720
1721static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol,
1722 struct snd_ctl_elem_value *ucontrol)
1723{
1724 ucontrol->value.integer.value[0] = kcontrol->private_value;
1725 return 0;
1726}
1727
1728static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer,
1729 unsigned char state)
1730{
1731 struct snd_usb_audio *chip = mixer->chip;
1732 int err;
1733 unsigned char buff[2];
1734
1735 buff[0] = 0x02;
1736 buff[1] = state ? 0x02 : 0x00;
1737
1738 err = snd_usb_lock_shutdown(chip);
1739 if (err < 0)
1740 return err;
1741 err = snd_usb_ctl_msg(chip->dev,
1742 usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT,
1743 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
1744 0x0202, 3, buff, 2);
1745 snd_usb_unlock_shutdown(chip);
1746 return err;
1747}
1748
1749static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol,
1750 struct snd_ctl_elem_value *ucontrol)
1751{
1752 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1753 unsigned char value = !!ucontrol->value.integer.value[0];
1754 int err;
1755
1756 if (kcontrol->private_value == value)
1757 return 0;
1758 kcontrol->private_value = value;
1759 err = snd_soundblaster_e1_switch_update(list->mixer, value);
1760 return err < 0 ? err : 1;
1761}
1762
1763static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list)
1764{
1765 return snd_soundblaster_e1_switch_update(list->mixer,
1766 list->kctl->private_value);
1767}
1768
1769static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol,
1770 struct snd_ctl_elem_info *uinfo)
1771{
1772 static const char *const texts[2] = {
1773 "Mic", "Aux"
1774 };
1775
1776 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1777}
1778
1779static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = {
1780 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1781 .name = "Input Source",
1782 .info = snd_soundblaster_e1_switch_info,
1783 .get = snd_soundblaster_e1_switch_get,
1784 .put = snd_soundblaster_e1_switch_put,
1785 .private_value = 0,
1786};
1787
1788static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer)
1789{
1790 return add_single_ctl_with_resume(mixer, 0,
1791 snd_soundblaster_e1_switch_resume,
1792 &snd_soundblaster_e1_input_switch,
1793 NULL);
1794}
1795
1796static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id)
1797{
1798 u16 buf = 0;
1799
1800 snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
1801 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1802 ch, snd_usb_ctrl_intf(chip) | (id << 8),
1803 &buf, 2);
1804}
1805
1806static int dell_dock_mixer_init(struct usb_mixer_interface *mixer)
1807{
1808 /* fix to 0dB playback volumes */
1809 dell_dock_init_vol(mixer->chip, 1, 16);
1810 dell_dock_init_vol(mixer->chip, 2, 16);
1811 dell_dock_init_vol(mixer->chip, 1, 19);
1812 dell_dock_init_vol(mixer->chip, 2, 19);
1813 return 0;
1814}
1815
1816/* RME Class Compliant device quirks */
1817
1818#define SND_RME_GET_STATUS1 23
1819#define SND_RME_GET_CURRENT_FREQ 17
1820#define SND_RME_CLK_SYSTEM_SHIFT 16
1821#define SND_RME_CLK_SYSTEM_MASK 0x1f
1822#define SND_RME_CLK_AES_SHIFT 8
1823#define SND_RME_CLK_SPDIF_SHIFT 12
1824#define SND_RME_CLK_AES_SPDIF_MASK 0xf
1825#define SND_RME_CLK_SYNC_SHIFT 6
1826#define SND_RME_CLK_SYNC_MASK 0x3
1827#define SND_RME_CLK_FREQMUL_SHIFT 18
1828#define SND_RME_CLK_FREQMUL_MASK 0x7
1829#define SND_RME_CLK_SYSTEM(x) \
1830 ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK)
1831#define SND_RME_CLK_AES(x) \
1832 ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1833#define SND_RME_CLK_SPDIF(x) \
1834 ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1835#define SND_RME_CLK_SYNC(x) \
1836 ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK)
1837#define SND_RME_CLK_FREQMUL(x) \
1838 ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK)
1839#define SND_RME_CLK_AES_LOCK 0x1
1840#define SND_RME_CLK_AES_SYNC 0x4
1841#define SND_RME_CLK_SPDIF_LOCK 0x2
1842#define SND_RME_CLK_SPDIF_SYNC 0x8
1843#define SND_RME_SPDIF_IF_SHIFT 4
1844#define SND_RME_SPDIF_FORMAT_SHIFT 5
1845#define SND_RME_BINARY_MASK 0x1
1846#define SND_RME_SPDIF_IF(x) \
1847 ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK)
1848#define SND_RME_SPDIF_FORMAT(x) \
1849 ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK)
1850
1851static const u32 snd_rme_rate_table[] = {
1852 32000, 44100, 48000, 50000,
1853 64000, 88200, 96000, 100000,
1854 128000, 176400, 192000, 200000,
1855 256000, 352800, 384000, 400000,
1856 512000, 705600, 768000, 800000
1857};
1858/* maximum number of items for AES and S/PDIF rates for above table */
1859#define SND_RME_RATE_IDX_AES_SPDIF_NUM 12
1860
1861enum snd_rme_domain {
1862 SND_RME_DOMAIN_SYSTEM,
1863 SND_RME_DOMAIN_AES,
1864 SND_RME_DOMAIN_SPDIF
1865};
1866
1867enum snd_rme_clock_status {
1868 SND_RME_CLOCK_NOLOCK,
1869 SND_RME_CLOCK_LOCK,
1870 SND_RME_CLOCK_SYNC
1871};
1872
1873static int snd_rme_read_value(struct snd_usb_audio *chip,
1874 unsigned int item,
1875 u32 *value)
1876{
1877 struct usb_device *dev = chip->dev;
1878 int err;
1879
1880 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
1881 item,
1882 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1883 0, 0,
1884 value, sizeof(*value));
1885 if (err < 0)
1886 dev_err(&dev->dev,
1887 "unable to issue vendor read request %d (ret = %d)",
1888 item, err);
1889 return err;
1890}
1891
1892static int snd_rme_get_status1(struct snd_kcontrol *kcontrol,
1893 u32 *status1)
1894{
1895 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1896 struct snd_usb_audio *chip = list->mixer->chip;
1897 int err;
1898
1899 err = snd_usb_lock_shutdown(chip);
1900 if (err < 0)
1901 return err;
1902 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1);
1903 snd_usb_unlock_shutdown(chip);
1904 return err;
1905}
1906
1907static int snd_rme_rate_get(struct snd_kcontrol *kcontrol,
1908 struct snd_ctl_elem_value *ucontrol)
1909{
1910 u32 status1;
1911 u32 rate = 0;
1912 int idx;
1913 int err;
1914
1915 err = snd_rme_get_status1(kcontrol, &status1);
1916 if (err < 0)
1917 return err;
1918 switch (kcontrol->private_value) {
1919 case SND_RME_DOMAIN_SYSTEM:
1920 idx = SND_RME_CLK_SYSTEM(status1);
1921 if (idx < ARRAY_SIZE(snd_rme_rate_table))
1922 rate = snd_rme_rate_table[idx];
1923 break;
1924 case SND_RME_DOMAIN_AES:
1925 idx = SND_RME_CLK_AES(status1);
1926 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
1927 rate = snd_rme_rate_table[idx];
1928 break;
1929 case SND_RME_DOMAIN_SPDIF:
1930 idx = SND_RME_CLK_SPDIF(status1);
1931 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
1932 rate = snd_rme_rate_table[idx];
1933 break;
1934 default:
1935 return -EINVAL;
1936 }
1937 ucontrol->value.integer.value[0] = rate;
1938 return 0;
1939}
1940
1941static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol,
1942 struct snd_ctl_elem_value *ucontrol)
1943{
1944 u32 status1;
1945 int idx = SND_RME_CLOCK_NOLOCK;
1946 int err;
1947
1948 err = snd_rme_get_status1(kcontrol, &status1);
1949 if (err < 0)
1950 return err;
1951 switch (kcontrol->private_value) {
1952 case SND_RME_DOMAIN_AES: /* AES */
1953 if (status1 & SND_RME_CLK_AES_SYNC)
1954 idx = SND_RME_CLOCK_SYNC;
1955 else if (status1 & SND_RME_CLK_AES_LOCK)
1956 idx = SND_RME_CLOCK_LOCK;
1957 break;
1958 case SND_RME_DOMAIN_SPDIF: /* SPDIF */
1959 if (status1 & SND_RME_CLK_SPDIF_SYNC)
1960 idx = SND_RME_CLOCK_SYNC;
1961 else if (status1 & SND_RME_CLK_SPDIF_LOCK)
1962 idx = SND_RME_CLOCK_LOCK;
1963 break;
1964 default:
1965 return -EINVAL;
1966 }
1967 ucontrol->value.enumerated.item[0] = idx;
1968 return 0;
1969}
1970
1971static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol,
1972 struct snd_ctl_elem_value *ucontrol)
1973{
1974 u32 status1;
1975 int err;
1976
1977 err = snd_rme_get_status1(kcontrol, &status1);
1978 if (err < 0)
1979 return err;
1980 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1);
1981 return 0;
1982}
1983
1984static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol,
1985 struct snd_ctl_elem_value *ucontrol)
1986{
1987 u32 status1;
1988 int err;
1989
1990 err = snd_rme_get_status1(kcontrol, &status1);
1991 if (err < 0)
1992 return err;
1993 ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1);
1994 return 0;
1995}
1996
1997static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol,
1998 struct snd_ctl_elem_value *ucontrol)
1999{
2000 u32 status1;
2001 int err;
2002
2003 err = snd_rme_get_status1(kcontrol, &status1);
2004 if (err < 0)
2005 return err;
2006 ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1);
2007 return 0;
2008}
2009
2010static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol,
2011 struct snd_ctl_elem_value *ucontrol)
2012{
2013 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2014 struct snd_usb_audio *chip = list->mixer->chip;
2015 u32 status1;
2016 const u64 num = 104857600000000ULL;
2017 u32 den;
2018 unsigned int freq;
2019 int err;
2020
2021 err = snd_usb_lock_shutdown(chip);
2022 if (err < 0)
2023 return err;
2024 err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1);
2025 if (err < 0)
2026 goto end;
2027 err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den);
2028 if (err < 0)
2029 goto end;
2030 freq = (den == 0) ? 0 : div64_u64(num, den);
2031 freq <<= SND_RME_CLK_FREQMUL(status1);
2032 ucontrol->value.integer.value[0] = freq;
2033
2034end:
2035 snd_usb_unlock_shutdown(chip);
2036 return err;
2037}
2038
2039static int snd_rme_rate_info(struct snd_kcontrol *kcontrol,
2040 struct snd_ctl_elem_info *uinfo)
2041{
2042 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2043 uinfo->count = 1;
2044 switch (kcontrol->private_value) {
2045 case SND_RME_DOMAIN_SYSTEM:
2046 uinfo->value.integer.min = 32000;
2047 uinfo->value.integer.max = 800000;
2048 break;
2049 case SND_RME_DOMAIN_AES:
2050 case SND_RME_DOMAIN_SPDIF:
2051 default:
2052 uinfo->value.integer.min = 0;
2053 uinfo->value.integer.max = 200000;
2054 }
2055 uinfo->value.integer.step = 0;
2056 return 0;
2057}
2058
2059static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol,
2060 struct snd_ctl_elem_info *uinfo)
2061{
2062 static const char *const sync_states[] = {
2063 "No Lock", "Lock", "Sync"
2064 };
2065
2066 return snd_ctl_enum_info(uinfo, 1,
2067 ARRAY_SIZE(sync_states), sync_states);
2068}
2069
2070static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol,
2071 struct snd_ctl_elem_info *uinfo)
2072{
2073 static const char *const spdif_if[] = {
2074 "Coaxial", "Optical"
2075 };
2076
2077 return snd_ctl_enum_info(uinfo, 1,
2078 ARRAY_SIZE(spdif_if), spdif_if);
2079}
2080
2081static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol,
2082 struct snd_ctl_elem_info *uinfo)
2083{
2084 static const char *const optical_type[] = {
2085 "Consumer", "Professional"
2086 };
2087
2088 return snd_ctl_enum_info(uinfo, 1,
2089 ARRAY_SIZE(optical_type), optical_type);
2090}
2091
2092static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol,
2093 struct snd_ctl_elem_info *uinfo)
2094{
2095 static const char *const sync_sources[] = {
2096 "Internal", "AES", "SPDIF", "Internal"
2097 };
2098
2099 return snd_ctl_enum_info(uinfo, 1,
2100 ARRAY_SIZE(sync_sources), sync_sources);
2101}
2102
2103static const struct snd_kcontrol_new snd_rme_controls[] = {
2104 {
2105 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2106 .name = "AES Rate",
2107 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2108 .info = snd_rme_rate_info,
2109 .get = snd_rme_rate_get,
2110 .private_value = SND_RME_DOMAIN_AES
2111 },
2112 {
2113 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2114 .name = "AES Sync",
2115 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2116 .info = snd_rme_sync_state_info,
2117 .get = snd_rme_sync_state_get,
2118 .private_value = SND_RME_DOMAIN_AES
2119 },
2120 {
2121 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2122 .name = "SPDIF Rate",
2123 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2124 .info = snd_rme_rate_info,
2125 .get = snd_rme_rate_get,
2126 .private_value = SND_RME_DOMAIN_SPDIF
2127 },
2128 {
2129 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2130 .name = "SPDIF Sync",
2131 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2132 .info = snd_rme_sync_state_info,
2133 .get = snd_rme_sync_state_get,
2134 .private_value = SND_RME_DOMAIN_SPDIF
2135 },
2136 {
2137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2138 .name = "SPDIF Interface",
2139 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2140 .info = snd_rme_spdif_if_info,
2141 .get = snd_rme_spdif_if_get,
2142 },
2143 {
2144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2145 .name = "SPDIF Format",
2146 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2147 .info = snd_rme_spdif_format_info,
2148 .get = snd_rme_spdif_format_get,
2149 },
2150 {
2151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2152 .name = "Sync Source",
2153 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2154 .info = snd_rme_sync_source_info,
2155 .get = snd_rme_sync_source_get
2156 },
2157 {
2158 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2159 .name = "System Rate",
2160 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2161 .info = snd_rme_rate_info,
2162 .get = snd_rme_rate_get,
2163 .private_value = SND_RME_DOMAIN_SYSTEM
2164 },
2165 {
2166 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2167 .name = "Current Frequency",
2168 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2169 .info = snd_rme_rate_info,
2170 .get = snd_rme_current_freq_get
2171 }
2172};
2173
2174static int snd_rme_controls_create(struct usb_mixer_interface *mixer)
2175{
2176 int err, i;
2177
2178 for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) {
2179 err = add_single_ctl_with_resume(mixer, 0,
2180 NULL,
2181 &snd_rme_controls[i],
2182 NULL);
2183 if (err < 0)
2184 return err;
2185 }
2186
2187 return 0;
2188}
2189
2190/*
2191 * RME Babyface Pro (FS)
2192 *
2193 * These devices exposes a couple of DSP functions via request to EP0.
2194 * Switches are available via control registers, while routing is controlled
2195 * by controlling the volume on each possible crossing point.
2196 * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with
2197 * 0dB being at dec. 32768.
2198 */
2199enum {
2200 SND_BBFPRO_CTL_REG1 = 0,
2201 SND_BBFPRO_CTL_REG2
2202};
2203
2204#define SND_BBFPRO_CTL_REG_MASK 1
2205#define SND_BBFPRO_CTL_IDX_MASK 0xff
2206#define SND_BBFPRO_CTL_IDX_SHIFT 1
2207#define SND_BBFPRO_CTL_VAL_MASK 1
2208#define SND_BBFPRO_CTL_VAL_SHIFT 9
2209#define SND_BBFPRO_CTL_REG1_CLK_MASTER 0
2210#define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1
2211#define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7
2212#define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8
2213#define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10
2214#define SND_BBFPRO_CTL_REG2_48V_AN1 0
2215#define SND_BBFPRO_CTL_REG2_48V_AN2 1
2216#define SND_BBFPRO_CTL_REG2_SENS_IN3 2
2217#define SND_BBFPRO_CTL_REG2_SENS_IN4 3
2218#define SND_BBFPRO_CTL_REG2_PAD_AN1 4
2219#define SND_BBFPRO_CTL_REG2_PAD_AN2 5
2220
2221#define SND_BBFPRO_MIXER_IDX_MASK 0x1ff
2222#define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff
2223#define SND_BBFPRO_MIXER_VAL_SHIFT 9
2224#define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf
2225#define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB
2226
2227#define SND_BBFPRO_USBREQ_CTL_REG1 0x10
2228#define SND_BBFPRO_USBREQ_CTL_REG2 0x17
2229#define SND_BBFPRO_USBREQ_MIXER 0x12
2230
2231static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg,
2232 u8 index, u8 value)
2233{
2234 int err;
2235 u16 usb_req, usb_idx, usb_val;
2236 struct snd_usb_audio *chip = mixer->chip;
2237
2238 err = snd_usb_lock_shutdown(chip);
2239 if (err < 0)
2240 return err;
2241
2242 if (reg == SND_BBFPRO_CTL_REG1) {
2243 usb_req = SND_BBFPRO_USBREQ_CTL_REG1;
2244 if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2245 usb_idx = 3;
2246 usb_val = value ? 3 : 0;
2247 } else {
2248 usb_idx = 1 << index;
2249 usb_val = value ? usb_idx : 0;
2250 }
2251 } else {
2252 usb_req = SND_BBFPRO_USBREQ_CTL_REG2;
2253 usb_idx = 1 << index;
2254 usb_val = value ? usb_idx : 0;
2255 }
2256
2257 err = snd_usb_ctl_msg(chip->dev,
2258 usb_sndctrlpipe(chip->dev, 0), usb_req,
2259 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2260 usb_val, usb_idx, NULL, 0);
2261
2262 snd_usb_unlock_shutdown(chip);
2263 return err;
2264}
2265
2266static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol,
2267 struct snd_ctl_elem_value *ucontrol)
2268{
2269 u8 reg, idx, val;
2270 int pv;
2271
2272 pv = kcontrol->private_value;
2273 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2274 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2275 val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT;
2276
2277 if ((reg == SND_BBFPRO_CTL_REG1 &&
2278 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2279 (reg == SND_BBFPRO_CTL_REG2 &&
2280 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2281 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2282 ucontrol->value.enumerated.item[0] = val;
2283 } else {
2284 ucontrol->value.integer.value[0] = val;
2285 }
2286 return 0;
2287}
2288
2289static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol,
2290 struct snd_ctl_elem_info *uinfo)
2291{
2292 u8 reg, idx;
2293 int pv;
2294
2295 pv = kcontrol->private_value;
2296 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2297 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2298
2299 if (reg == SND_BBFPRO_CTL_REG1 &&
2300 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2301 static const char * const texts[2] = {
2302 "AutoSync",
2303 "Internal"
2304 };
2305 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2306 } else if (reg == SND_BBFPRO_CTL_REG2 &&
2307 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2308 idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) {
2309 static const char * const texts[2] = {
2310 "-10dBV",
2311 "+4dBu"
2312 };
2313 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2314 }
2315
2316 uinfo->count = 1;
2317 uinfo->value.integer.min = 0;
2318 uinfo->value.integer.max = 1;
2319 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2320 return 0;
2321}
2322
2323static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol,
2324 struct snd_ctl_elem_value *ucontrol)
2325{
2326 int err;
2327 u8 reg, idx;
2328 int old_value, pv, val;
2329
2330 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2331 struct usb_mixer_interface *mixer = list->mixer;
2332
2333 pv = kcontrol->private_value;
2334 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2335 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2336 old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2337
2338 if ((reg == SND_BBFPRO_CTL_REG1 &&
2339 idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2340 (reg == SND_BBFPRO_CTL_REG2 &&
2341 (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2342 idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2343 val = ucontrol->value.enumerated.item[0];
2344 } else {
2345 val = ucontrol->value.integer.value[0];
2346 }
2347
2348 if (val > 1)
2349 return -EINVAL;
2350
2351 if (val == old_value)
2352 return 0;
2353
2354 kcontrol->private_value = reg
2355 | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT)
2356 | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT);
2357
2358 err = snd_bbfpro_ctl_update(mixer, reg, idx, val);
2359 return err < 0 ? err : 1;
2360}
2361
2362static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list)
2363{
2364 u8 reg, idx;
2365 int value, pv;
2366
2367 pv = list->kctl->private_value;
2368 reg = pv & SND_BBFPRO_CTL_REG_MASK;
2369 idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2370 value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2371
2372 return snd_bbfpro_ctl_update(list->mixer, reg, idx, value);
2373}
2374
2375static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index,
2376 u32 value)
2377{
2378 struct snd_usb_audio *chip = mixer->chip;
2379 int err;
2380 u16 idx;
2381 u16 usb_idx, usb_val;
2382 u32 v;
2383
2384 err = snd_usb_lock_shutdown(chip);
2385 if (err < 0)
2386 return err;
2387
2388 idx = index & SND_BBFPRO_MIXER_IDX_MASK;
2389 // 18 bit linear volume, split so 2 bits end up in index.
2390 v = value & SND_BBFPRO_MIXER_VAL_MASK;
2391 usb_idx = idx | (v & 0x3) << 14;
2392 usb_val = (v >> 2) & 0xffff;
2393
2394 err = snd_usb_ctl_msg(chip->dev,
2395 usb_sndctrlpipe(chip->dev, 0),
2396 SND_BBFPRO_USBREQ_MIXER,
2397 USB_DIR_OUT | USB_TYPE_VENDOR |
2398 USB_RECIP_DEVICE,
2399 usb_val, usb_idx, NULL, 0);
2400
2401 snd_usb_unlock_shutdown(chip);
2402 return err;
2403}
2404
2405static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol,
2406 struct snd_ctl_elem_value *ucontrol)
2407{
2408 ucontrol->value.integer.value[0] =
2409 kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2410 return 0;
2411}
2412
2413static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol,
2414 struct snd_ctl_elem_info *uinfo)
2415{
2416 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2417 uinfo->count = 1;
2418 uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN;
2419 uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX;
2420 return 0;
2421}
2422
2423static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol,
2424 struct snd_ctl_elem_value *ucontrol)
2425{
2426 int err;
2427 u16 idx;
2428 u32 new_val, old_value, uvalue;
2429 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2430 struct usb_mixer_interface *mixer = list->mixer;
2431
2432 uvalue = ucontrol->value.integer.value[0];
2433 idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK;
2434 old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2435
2436 if (uvalue > SND_BBFPRO_MIXER_VAL_MAX)
2437 return -EINVAL;
2438
2439 if (uvalue == old_value)
2440 return 0;
2441
2442 new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK;
2443
2444 kcontrol->private_value = idx
2445 | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT);
2446
2447 err = snd_bbfpro_vol_update(mixer, idx, new_val);
2448 return err < 0 ? err : 1;
2449}
2450
2451static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list)
2452{
2453 int pv = list->kctl->private_value;
2454 u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK;
2455 u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT)
2456 & SND_BBFPRO_MIXER_VAL_MASK;
2457 return snd_bbfpro_vol_update(list->mixer, idx, val);
2458}
2459
2460// Predfine elements
2461static const struct snd_kcontrol_new snd_bbfpro_ctl_control = {
2462 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2463 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2464 .index = 0,
2465 .info = snd_bbfpro_ctl_info,
2466 .get = snd_bbfpro_ctl_get,
2467 .put = snd_bbfpro_ctl_put
2468};
2469
2470static const struct snd_kcontrol_new snd_bbfpro_vol_control = {
2471 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2472 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2473 .index = 0,
2474 .info = snd_bbfpro_vol_info,
2475 .get = snd_bbfpro_vol_get,
2476 .put = snd_bbfpro_vol_put
2477};
2478
2479static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg,
2480 u8 index, char *name)
2481{
2482 struct snd_kcontrol_new knew = snd_bbfpro_ctl_control;
2483
2484 knew.name = name;
2485 knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK)
2486 | ((index & SND_BBFPRO_CTL_IDX_MASK)
2487 << SND_BBFPRO_CTL_IDX_SHIFT);
2488
2489 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume,
2490 &knew, NULL);
2491}
2492
2493static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index,
2494 char *name)
2495{
2496 struct snd_kcontrol_new knew = snd_bbfpro_vol_control;
2497
2498 knew.name = name;
2499 knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK;
2500
2501 return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume,
2502 &knew, NULL);
2503}
2504
2505static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer)
2506{
2507 int err, i, o;
2508 char name[48];
2509
2510 static const char * const input[] = {
2511 "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3",
2512 "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2513
2514 static const char * const output[] = {
2515 "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4",
2516 "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2517
2518 for (o = 0 ; o < 12 ; ++o) {
2519 for (i = 0 ; i < 12 ; ++i) {
2520 // Line routing
2521 snprintf(name, sizeof(name),
2522 "%s-%s-%s Playback Volume",
2523 (i < 2 ? "Mic" : "Line"),
2524 input[i], output[o]);
2525 err = snd_bbfpro_vol_add(mixer, (26 * o + i), name);
2526 if (err < 0)
2527 return err;
2528
2529 // PCM routing... yes, it is output remapping
2530 snprintf(name, sizeof(name),
2531 "PCM-%s-%s Playback Volume",
2532 output[i], output[o]);
2533 err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i),
2534 name);
2535 if (err < 0)
2536 return err;
2537 }
2538 }
2539
2540 // Control Reg 1
2541 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2542 SND_BBFPRO_CTL_REG1_CLK_OPTICAL,
2543 "Sample Clock Source");
2544 if (err < 0)
2545 return err;
2546
2547 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2548 SND_BBFPRO_CTL_REG1_SPDIF_PRO,
2549 "IEC958 Pro Mask");
2550 if (err < 0)
2551 return err;
2552
2553 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2554 SND_BBFPRO_CTL_REG1_SPDIF_EMPH,
2555 "IEC958 Emphasis");
2556 if (err < 0)
2557 return err;
2558
2559 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2560 SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL,
2561 "IEC958 Switch");
2562 if (err < 0)
2563 return err;
2564
2565 // Control Reg 2
2566 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2567 SND_BBFPRO_CTL_REG2_48V_AN1,
2568 "Mic-AN1 48V");
2569 if (err < 0)
2570 return err;
2571
2572 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2573 SND_BBFPRO_CTL_REG2_48V_AN2,
2574 "Mic-AN2 48V");
2575 if (err < 0)
2576 return err;
2577
2578 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2579 SND_BBFPRO_CTL_REG2_SENS_IN3,
2580 "Line-IN3 Sens.");
2581 if (err < 0)
2582 return err;
2583
2584 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2585 SND_BBFPRO_CTL_REG2_SENS_IN4,
2586 "Line-IN4 Sens.");
2587 if (err < 0)
2588 return err;
2589
2590 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2591 SND_BBFPRO_CTL_REG2_PAD_AN1,
2592 "Mic-AN1 PAD");
2593 if (err < 0)
2594 return err;
2595
2596 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2597 SND_BBFPRO_CTL_REG2_PAD_AN2,
2598 "Mic-AN2 PAD");
2599 if (err < 0)
2600 return err;
2601
2602 return 0;
2603}
2604
2605/*
2606 * Pioneer DJ DJM Mixers
2607 *
2608 * These devices generally have options for soft-switching the playback and
2609 * capture sources in addition to the recording level. Although different
2610 * devices have different configurations, there seems to be canonical values
2611 * for specific capture/playback types: See the definitions of these below.
2612 *
2613 * The wValue is masked with the stereo channel number. e.g. Setting Ch2 to
2614 * capture phono would be 0x0203. Capture, playback and capture level have
2615 * different wIndexes.
2616 */
2617
2618// Capture types
2619#define SND_DJM_CAP_LINE 0x00
2620#define SND_DJM_CAP_CDLINE 0x01
2621#define SND_DJM_CAP_DIGITAL 0x02
2622#define SND_DJM_CAP_PHONO 0x03
2623#define SND_DJM_CAP_PFADER 0x06
2624#define SND_DJM_CAP_XFADERA 0x07
2625#define SND_DJM_CAP_XFADERB 0x08
2626#define SND_DJM_CAP_MIC 0x09
2627#define SND_DJM_CAP_AUX 0x0d
2628#define SND_DJM_CAP_RECOUT 0x0a
2629#define SND_DJM_CAP_NONE 0x0f
2630#define SND_DJM_CAP_CH1PFADER 0x11
2631#define SND_DJM_CAP_CH2PFADER 0x12
2632#define SND_DJM_CAP_CH3PFADER 0x13
2633#define SND_DJM_CAP_CH4PFADER 0x14
2634
2635// Playback types
2636#define SND_DJM_PB_CH1 0x00
2637#define SND_DJM_PB_CH2 0x01
2638#define SND_DJM_PB_AUX 0x04
2639
2640#define SND_DJM_WINDEX_CAP 0x8002
2641#define SND_DJM_WINDEX_CAPLVL 0x8003
2642#define SND_DJM_WINDEX_PB 0x8016
2643
2644// kcontrol->private_value layout
2645#define SND_DJM_VALUE_MASK 0x0000ffff
2646#define SND_DJM_GROUP_MASK 0x00ff0000
2647#define SND_DJM_DEVICE_MASK 0xff000000
2648#define SND_DJM_GROUP_SHIFT 16
2649#define SND_DJM_DEVICE_SHIFT 24
2650
2651// device table index
2652// used for the snd_djm_devices table, so please update accordingly
2653#define SND_DJM_250MK2_IDX 0x0
2654#define SND_DJM_750_IDX 0x1
2655#define SND_DJM_850_IDX 0x2
2656#define SND_DJM_900NXS2_IDX 0x3
2657
2658
2659#define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \
2660 .name = _name, \
2661 .options = snd_djm_opts_##suffix, \
2662 .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \
2663 .default_value = _default_value, \
2664 .wIndex = _windex }
2665
2666#define SND_DJM_DEVICE(suffix) { \
2667 .controls = snd_djm_ctls_##suffix, \
2668 .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) }
2669
2670
2671struct snd_djm_device {
2672 const char *name;
2673 const struct snd_djm_ctl *controls;
2674 size_t ncontrols;
2675};
2676
2677struct snd_djm_ctl {
2678 const char *name;
2679 const u16 *options;
2680 size_t noptions;
2681 u16 default_value;
2682 u16 wIndex;
2683};
2684
2685static const char *snd_djm_get_label_caplevel(u16 wvalue)
2686{
2687 switch (wvalue) {
2688 case 0x0000: return "-19dB";
2689 case 0x0100: return "-15dB";
2690 case 0x0200: return "-10dB";
2691 case 0x0300: return "-5dB";
2692 default: return NULL;
2693 }
2694};
2695
2696static const char *snd_djm_get_label_cap_common(u16 wvalue)
2697{
2698 switch (wvalue & 0x00ff) {
2699 case SND_DJM_CAP_LINE: return "Control Tone LINE";
2700 case SND_DJM_CAP_CDLINE: return "Control Tone CD/LINE";
2701 case SND_DJM_CAP_DIGITAL: return "Control Tone DIGITAL";
2702 case SND_DJM_CAP_PHONO: return "Control Tone PHONO";
2703 case SND_DJM_CAP_PFADER: return "Post Fader";
2704 case SND_DJM_CAP_XFADERA: return "Cross Fader A";
2705 case SND_DJM_CAP_XFADERB: return "Cross Fader B";
2706 case SND_DJM_CAP_MIC: return "Mic";
2707 case SND_DJM_CAP_RECOUT: return "Rec Out";
2708 case SND_DJM_CAP_AUX: return "Aux";
2709 case SND_DJM_CAP_NONE: return "None";
2710 case SND_DJM_CAP_CH1PFADER: return "Post Fader Ch1";
2711 case SND_DJM_CAP_CH2PFADER: return "Post Fader Ch2";
2712 case SND_DJM_CAP_CH3PFADER: return "Post Fader Ch3";
2713 case SND_DJM_CAP_CH4PFADER: return "Post Fader Ch4";
2714 default: return NULL;
2715 }
2716};
2717
2718// The DJM-850 has different values for CD/LINE and LINE capture
2719// control options than the other DJM declared in this file.
2720static const char *snd_djm_get_label_cap_850(u16 wvalue)
2721{
2722 switch (wvalue & 0x00ff) {
2723 case 0x00: return "Control Tone CD/LINE";
2724 case 0x01: return "Control Tone LINE";
2725 default: return snd_djm_get_label_cap_common(wvalue);
2726 }
2727};
2728
2729static const char *snd_djm_get_label_cap(u8 device_idx, u16 wvalue)
2730{
2731 switch (device_idx) {
2732 case SND_DJM_850_IDX: return snd_djm_get_label_cap_850(wvalue);
2733 default: return snd_djm_get_label_cap_common(wvalue);
2734 }
2735};
2736
2737static const char *snd_djm_get_label_pb(u16 wvalue)
2738{
2739 switch (wvalue & 0x00ff) {
2740 case SND_DJM_PB_CH1: return "Ch1";
2741 case SND_DJM_PB_CH2: return "Ch2";
2742 case SND_DJM_PB_AUX: return "Aux";
2743 default: return NULL;
2744 }
2745};
2746
2747static const char *snd_djm_get_label(u8 device_idx, u16 wvalue, u16 windex)
2748{
2749 switch (windex) {
2750 case SND_DJM_WINDEX_CAPLVL: return snd_djm_get_label_caplevel(wvalue);
2751 case SND_DJM_WINDEX_CAP: return snd_djm_get_label_cap(device_idx, wvalue);
2752 case SND_DJM_WINDEX_PB: return snd_djm_get_label_pb(wvalue);
2753 default: return NULL;
2754 }
2755};
2756
2757// common DJM capture level option values
2758static const u16 snd_djm_opts_cap_level[] = {
2759 0x0000, 0x0100, 0x0200, 0x0300 };
2760
2761
2762// DJM-250MK2
2763static const u16 snd_djm_opts_250mk2_cap1[] = {
2764 0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a };
2765
2766static const u16 snd_djm_opts_250mk2_cap2[] = {
2767 0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a };
2768
2769static const u16 snd_djm_opts_250mk2_cap3[] = {
2770 0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d };
2771
2772static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 };
2773static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 };
2774static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 };
2775
2776static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = {
2777 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2778 SND_DJM_CTL("Ch1 Input", 250mk2_cap1, 2, SND_DJM_WINDEX_CAP),
2779 SND_DJM_CTL("Ch2 Input", 250mk2_cap2, 2, SND_DJM_WINDEX_CAP),
2780 SND_DJM_CTL("Ch3 Input", 250mk2_cap3, 0, SND_DJM_WINDEX_CAP),
2781 SND_DJM_CTL("Ch1 Output", 250mk2_pb1, 0, SND_DJM_WINDEX_PB),
2782 SND_DJM_CTL("Ch2 Output", 250mk2_pb2, 1, SND_DJM_WINDEX_PB),
2783 SND_DJM_CTL("Ch3 Output", 250mk2_pb3, 2, SND_DJM_WINDEX_PB)
2784};
2785
2786
2787// DJM-750
2788static const u16 snd_djm_opts_750_cap1[] = {
2789 0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
2790static const u16 snd_djm_opts_750_cap2[] = {
2791 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
2792static const u16 snd_djm_opts_750_cap3[] = {
2793 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
2794static const u16 snd_djm_opts_750_cap4[] = {
2795 0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
2796
2797static const struct snd_djm_ctl snd_djm_ctls_750[] = {
2798 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2799 SND_DJM_CTL("Ch1 Input", 750_cap1, 2, SND_DJM_WINDEX_CAP),
2800 SND_DJM_CTL("Ch2 Input", 750_cap2, 2, SND_DJM_WINDEX_CAP),
2801 SND_DJM_CTL("Ch3 Input", 750_cap3, 0, SND_DJM_WINDEX_CAP),
2802 SND_DJM_CTL("Ch4 Input", 750_cap4, 0, SND_DJM_WINDEX_CAP)
2803};
2804
2805
2806// DJM-850
2807static const u16 snd_djm_opts_850_cap1[] = {
2808 0x0100, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
2809static const u16 snd_djm_opts_850_cap2[] = {
2810 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
2811static const u16 snd_djm_opts_850_cap3[] = {
2812 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
2813static const u16 snd_djm_opts_850_cap4[] = {
2814 0x0400, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
2815
2816static const struct snd_djm_ctl snd_djm_ctls_850[] = {
2817 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2818 SND_DJM_CTL("Ch1 Input", 850_cap1, 1, SND_DJM_WINDEX_CAP),
2819 SND_DJM_CTL("Ch2 Input", 850_cap2, 0, SND_DJM_WINDEX_CAP),
2820 SND_DJM_CTL("Ch3 Input", 850_cap3, 0, SND_DJM_WINDEX_CAP),
2821 SND_DJM_CTL("Ch4 Input", 850_cap4, 1, SND_DJM_WINDEX_CAP)
2822};
2823
2824
2825// DJM-900NXS2
2826static const u16 snd_djm_opts_900nxs2_cap1[] = {
2827 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a };
2828static const u16 snd_djm_opts_900nxs2_cap2[] = {
2829 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a };
2830static const u16 snd_djm_opts_900nxs2_cap3[] = {
2831 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a };
2832static const u16 snd_djm_opts_900nxs2_cap4[] = {
2833 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a };
2834static const u16 snd_djm_opts_900nxs2_cap5[] = {
2835 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 };
2836
2837static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = {
2838 SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2839 SND_DJM_CTL("Ch1 Input", 900nxs2_cap1, 2, SND_DJM_WINDEX_CAP),
2840 SND_DJM_CTL("Ch2 Input", 900nxs2_cap2, 2, SND_DJM_WINDEX_CAP),
2841 SND_DJM_CTL("Ch3 Input", 900nxs2_cap3, 2, SND_DJM_WINDEX_CAP),
2842 SND_DJM_CTL("Ch4 Input", 900nxs2_cap4, 2, SND_DJM_WINDEX_CAP),
2843 SND_DJM_CTL("Ch5 Input", 900nxs2_cap5, 3, SND_DJM_WINDEX_CAP)
2844};
2845
2846
2847static const struct snd_djm_device snd_djm_devices[] = {
2848 SND_DJM_DEVICE(250mk2),
2849 SND_DJM_DEVICE(750),
2850 SND_DJM_DEVICE(850),
2851 SND_DJM_DEVICE(900nxs2)
2852};
2853
2854
2855static int snd_djm_controls_info(struct snd_kcontrol *kctl,
2856 struct snd_ctl_elem_info *info)
2857{
2858 unsigned long private_value = kctl->private_value;
2859 u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
2860 u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
2861 const struct snd_djm_device *device = &snd_djm_devices[device_idx];
2862 const char *name;
2863 const struct snd_djm_ctl *ctl;
2864 size_t noptions;
2865
2866 if (ctl_idx >= device->ncontrols)
2867 return -EINVAL;
2868
2869 ctl = &device->controls[ctl_idx];
2870 noptions = ctl->noptions;
2871 if (info->value.enumerated.item >= noptions)
2872 info->value.enumerated.item = noptions - 1;
2873
2874 name = snd_djm_get_label(device_idx,
2875 ctl->options[info->value.enumerated.item],
2876 ctl->wIndex);
2877 if (!name)
2878 return -EINVAL;
2879
2880 strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name));
2881 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2882 info->count = 1;
2883 info->value.enumerated.items = noptions;
2884 return 0;
2885}
2886
2887static int snd_djm_controls_update(struct usb_mixer_interface *mixer,
2888 u8 device_idx, u8 group, u16 value)
2889{
2890 int err;
2891 const struct snd_djm_device *device = &snd_djm_devices[device_idx];
2892
2893 if ((group >= device->ncontrols) || value >= device->controls[group].noptions)
2894 return -EINVAL;
2895
2896 err = snd_usb_lock_shutdown(mixer->chip);
2897 if (err)
2898 return err;
2899
2900 err = snd_usb_ctl_msg(
2901 mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0),
2902 USB_REQ_SET_FEATURE,
2903 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2904 device->controls[group].options[value],
2905 device->controls[group].wIndex,
2906 NULL, 0);
2907
2908 snd_usb_unlock_shutdown(mixer->chip);
2909 return err;
2910}
2911
2912static int snd_djm_controls_get(struct snd_kcontrol *kctl,
2913 struct snd_ctl_elem_value *elem)
2914{
2915 elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK;
2916 return 0;
2917}
2918
2919static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem)
2920{
2921 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
2922 struct usb_mixer_interface *mixer = list->mixer;
2923 unsigned long private_value = kctl->private_value;
2924
2925 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
2926 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
2927 u16 value = elem->value.enumerated.item[0];
2928
2929 kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) |
2930 (group << SND_DJM_GROUP_SHIFT) |
2931 value);
2932
2933 return snd_djm_controls_update(mixer, device, group, value);
2934}
2935
2936static int snd_djm_controls_resume(struct usb_mixer_elem_list *list)
2937{
2938 unsigned long private_value = list->kctl->private_value;
2939 u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
2940 u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
2941 u16 value = (private_value & SND_DJM_VALUE_MASK);
2942
2943 return snd_djm_controls_update(list->mixer, device, group, value);
2944}
2945
2946static int snd_djm_controls_create(struct usb_mixer_interface *mixer,
2947 const u8 device_idx)
2948{
2949 int err, i;
2950 u16 value;
2951
2952 const struct snd_djm_device *device = &snd_djm_devices[device_idx];
2953
2954 struct snd_kcontrol_new knew = {
2955 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2956 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2957 .index = 0,
2958 .info = snd_djm_controls_info,
2959 .get = snd_djm_controls_get,
2960 .put = snd_djm_controls_put
2961 };
2962
2963 for (i = 0; i < device->ncontrols; i++) {
2964 value = device->controls[i].default_value;
2965 knew.name = device->controls[i].name;
2966 knew.private_value = (
2967 ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) |
2968 (i << SND_DJM_GROUP_SHIFT) |
2969 value);
2970 err = snd_djm_controls_update(mixer, device_idx, i, value);
2971 if (err)
2972 return err;
2973 err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume,
2974 &knew, NULL);
2975 if (err)
2976 return err;
2977 }
2978 return 0;
2979}
2980
2981int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
2982{
2983 int err = 0;
2984
2985 err = snd_usb_soundblaster_remote_init(mixer);
2986 if (err < 0)
2987 return err;
2988
2989 switch (mixer->chip->usb_id) {
2990 /* Tascam US-16x08 */
2991 case USB_ID(0x0644, 0x8047):
2992 err = snd_us16x08_controls_create(mixer);
2993 break;
2994 case USB_ID(0x041e, 0x3020):
2995 case USB_ID(0x041e, 0x3040):
2996 case USB_ID(0x041e, 0x3042):
2997 case USB_ID(0x041e, 0x30df):
2998 case USB_ID(0x041e, 0x3048):
2999 err = snd_audigy2nx_controls_create(mixer);
3000 if (err < 0)
3001 break;
3002 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx",
3003 mixer, snd_audigy2nx_proc_read);
3004 break;
3005
3006 /* EMU0204 */
3007 case USB_ID(0x041e, 0x3f19):
3008 err = snd_emu0204_controls_create(mixer);
3009 break;
3010
3011 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
3012 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
3013 err = snd_c400_create_mixer(mixer);
3014 break;
3015
3016 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
3017 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
3018 err = snd_ftu_create_mixer(mixer);
3019 break;
3020
3021 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
3022 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
3023 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
3024 err = snd_xonar_u1_controls_create(mixer);
3025 break;
3026
3027 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
3028 err = snd_microii_controls_create(mixer);
3029 break;
3030
3031 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */
3032 err = snd_mbox1_create_sync_switch(mixer);
3033 break;
3034
3035 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
3036 err = snd_nativeinstruments_create_mixer(mixer,
3037 snd_nativeinstruments_ta6_mixers,
3038 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
3039 break;
3040
3041 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
3042 err = snd_nativeinstruments_create_mixer(mixer,
3043 snd_nativeinstruments_ta10_mixers,
3044 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
3045 break;
3046
3047 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
3048 /* detection is disabled in mixer_maps.c */
3049 err = snd_create_std_mono_table(mixer, ebox44_table);
3050 break;
3051
3052 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */
3053 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */
3054 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */
3055 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */
3056 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */
3057 err = snd_scarlett_controls_create(mixer);
3058 break;
3059
3060 case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
3061 case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
3062 case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
3063 case USB_ID(0x1235, 0x8211): /* Focusrite Scarlett Solo 3rd Gen */
3064 case USB_ID(0x1235, 0x8210): /* Focusrite Scarlett 2i2 3rd Gen */
3065 case USB_ID(0x1235, 0x8212): /* Focusrite Scarlett 4i4 3rd Gen */
3066 case USB_ID(0x1235, 0x8213): /* Focusrite Scarlett 8i6 3rd Gen */
3067 case USB_ID(0x1235, 0x8214): /* Focusrite Scarlett 18i8 3rd Gen */
3068 case USB_ID(0x1235, 0x8215): /* Focusrite Scarlett 18i20 3rd Gen */
3069 err = snd_scarlett_gen2_init(mixer);
3070 break;
3071
3072 case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
3073 err = snd_soundblaster_e1_switch_create(mixer);
3074 break;
3075 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
3076 err = dell_dock_mixer_init(mixer);
3077 break;
3078
3079 case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */
3080 case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */
3081 case USB_ID(0x2a39, 0x3fd4): /* RME */
3082 err = snd_rme_controls_create(mixer);
3083 break;
3084
3085 case USB_ID(0x0194f, 0x010c): /* Presonus Studio 1810c */
3086 err = snd_sc1810_init_mixer(mixer);
3087 break;
3088 case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */
3089 err = snd_bbfpro_controls_create(mixer);
3090 break;
3091 case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */
3092 err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX);
3093 break;
3094 case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */
3095 err = snd_djm_controls_create(mixer, SND_DJM_750_IDX);
3096 break;
3097 case USB_ID(0x08e4, 0x0163): /* Pioneer DJ DJM-850 */
3098 err = snd_djm_controls_create(mixer, SND_DJM_850_IDX);
3099 break;
3100 case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */
3101 err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX);
3102 break;
3103 }
3104
3105 return err;
3106}
3107
3108#ifdef CONFIG_PM
3109void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
3110{
3111 switch (mixer->chip->usb_id) {
3112 case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
3113 dell_dock_mixer_init(mixer);
3114 break;
3115 }
3116}
3117#endif
3118
3119void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
3120 int unitid)
3121{
3122 if (!mixer->rc_cfg)
3123 return;
3124 /* unit ids specific to Extigy/Audigy 2 NX: */
3125 switch (unitid) {
3126 case 0: /* remote control */
3127 mixer->rc_urb->dev = mixer->chip->dev;
3128 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
3129 break;
3130 case 4: /* digital in jack */
3131 case 7: /* line in jacks */
3132 case 19: /* speaker out jacks */
3133 case 20: /* headphones out jack */
3134 break;
3135 /* live24ext: 4 = line-in jack */
3136 case 3: /* hp-out jack (may actuate Mute) */
3137 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
3138 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
3139 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
3140 break;
3141 default:
3142 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
3143 break;
3144 }
3145}
3146
3147static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
3148 struct usb_mixer_elem_info *cval,
3149 struct snd_kcontrol *kctl)
3150{
3151 /* Approximation using 10 ranges based on output measurement on hw v1.2.
3152 * This seems close to the cubic mapping e.g. alsamixer uses. */
3153 static const DECLARE_TLV_DB_RANGE(scale,
3154 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970),
3155 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160),
3156 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710),
3157 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560),
3158 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324),
3159 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031),
3160 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393),
3161 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032),
3162 32, 40, TLV_DB_MINMAX_ITEM(-968, -490),
3163 41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
3164 );
3165
3166 if (cval->min == 0 && cval->max == 50) {
3167 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
3168 kctl->tlv.p = scale;
3169 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
3170 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
3171
3172 } else if (cval->min == 0 && cval->max <= 1000) {
3173 /* Some other clearly broken DragonFly variant.
3174 * At least a 0..53 variant (hw v1.0) exists.
3175 */
3176 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
3177 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
3178 }
3179}
3180
3181void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
3182 struct usb_mixer_elem_info *cval, int unitid,
3183 struct snd_kcontrol *kctl)
3184{
3185 switch (mixer->chip->usb_id) {
3186 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
3187 if (unitid == 7 && cval->control == UAC_FU_VOLUME)
3188 snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
3189 break;
3190 /* lowest playback value is muted on C-Media devices */
3191 case USB_ID(0x0d8c, 0x000c):
3192 case USB_ID(0x0d8c, 0x0014):
3193 if (strstr(kctl->id.name, "Playback"))
3194 cval->min_mute = 1;
3195 break;
3196 }
3197}
3198