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