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