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