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