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