blob: f4b12c216f1cd55c2db4396746a5abc9f20ed302 [file] [log] [blame]
Daniel Mack7b1eda22010-03-11 21:13:22 +01001/*
2 * USB Audio Driver for ALSA
3 *
4 * Quirks and vendor-specific extensions for mixer interfaces
5 *
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7 *
8 * Many codes borrowed from audio.c by
9 * Alan Cox (alan@lxorguk.ukuu.org.uk)
10 * Thomas Sailer (sailer@ife.ee.ethz.ch)
11 *
Przemek Rudy066624c2013-06-27 23:52:33 +020012 * Audio Advantage Micro II support added by:
13 * Przemek Rudy (prudy1@o2.pl)
Daniel Mack7b1eda22010-03-11 21:13:22 +010014 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 */
29
30#include <linux/init.h>
Stephen Rothwell36db0452010-03-29 16:02:50 +110031#include <linux/slab.h>
Daniel Mack7b1eda22010-03-11 21:13:22 +010032#include <linux/usb.h>
33#include <linux/usb/audio.h>
34
Przemek Rudy066624c2013-06-27 23:52:33 +020035#include <sound/asoundef.h>
Daniel Mack7b1eda22010-03-11 21:13:22 +010036#include <sound/core.h>
37#include <sound/control.h>
38#include <sound/hwdep.h>
39#include <sound/info.h>
40
41#include "usbaudio.h"
Daniel Mackf0b5e632010-03-11 21:13:23 +010042#include "mixer.h"
Daniel Mack7b1eda22010-03-11 21:13:22 +010043#include "mixer_quirks.h"
44#include "helper.h"
45
Daniel Mackd5a0bf62011-05-25 09:09:03 +020046extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;
47
Mark Hillsb71dad182012-06-09 13:16:38 +010048struct std_mono_table {
49 unsigned int unitid, control, cmask;
50 int val_type;
51 const char *name;
52 snd_kcontrol_tlv_rw_t *tlv_callback;
53};
54
Felix Homann8a4d1d32012-04-23 20:24:23 +020055/* private_free callback */
56static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
57{
58 kfree(kctl->private_data);
59 kctl->private_data = NULL;
60}
61
62/* This function allows for the creation of standard UAC controls.
63 * See the quirks for M-Audio FTUs or Ebox-44.
64 * If you don't want to set a TLV callback pass NULL.
65 *
66 * Since there doesn't seem to be a devices that needs a multichannel
67 * version, we keep it mono for simplicity.
68 */
Eldad Zack9f814102012-11-28 23:55:35 +010069static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
Felix Homann8a4d1d32012-04-23 20:24:23 +020070 unsigned int unitid,
71 unsigned int control,
72 unsigned int cmask,
73 int val_type,
Eldad Zack9f814102012-11-28 23:55:35 +010074 unsigned int idx_off,
Felix Homann8a4d1d32012-04-23 20:24:23 +020075 const char *name,
76 snd_kcontrol_tlv_rw_t *tlv_callback)
77{
78 int err;
79 struct usb_mixer_elem_info *cval;
80 struct snd_kcontrol *kctl;
81
82 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
83 if (!cval)
84 return -ENOMEM;
85
86 cval->id = unitid;
87 cval->mixer = mixer;
88 cval->val_type = val_type;
89 cval->channels = 1;
90 cval->control = control;
91 cval->cmask = cmask;
Eldad Zack9f814102012-11-28 23:55:35 +010092 cval->idx_off = idx_off;
Felix Homann8a4d1d32012-04-23 20:24:23 +020093
Mark Hills7df4a692012-05-11 18:31:55 +010094 /* get_min_max() is called only for integer volumes later,
95 * so provide a short-cut for booleans */
Felix Homann8a4d1d32012-04-23 20:24:23 +020096 cval->min = 0;
97 cval->max = 1;
98 cval->res = 0;
99 cval->dBmin = 0;
100 cval->dBmax = 0;
101
102 /* Create control */
103 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
104 if (!kctl) {
105 kfree(cval);
106 return -ENOMEM;
107 }
108
109 /* Set name */
110 snprintf(kctl->id.name, sizeof(kctl->id.name), name);
111 kctl->private_free = usb_mixer_elem_free;
112
113 /* set TLV */
114 if (tlv_callback) {
115 kctl->tlv.c = tlv_callback;
116 kctl->vd[0].access |=
117 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
118 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
119 }
120 /* Add control to mixer */
121 err = snd_usb_mixer_add_control(mixer, kctl);
122 if (err < 0)
123 return err;
124
125 return 0;
126}
127
Eldad Zack9f814102012-11-28 23:55:35 +0100128static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
129 unsigned int unitid,
130 unsigned int control,
131 unsigned int cmask,
132 int val_type,
133 const char *name,
134 snd_kcontrol_tlv_rw_t *tlv_callback)
135{
136 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
137 val_type, 0 /* Offset */, name, tlv_callback);
138}
139
Daniel Mack7b1eda22010-03-11 21:13:22 +0100140/*
Mark Hillsb71dad182012-06-09 13:16:38 +0100141 * Create a set of standard UAC controls from a table
142 */
143static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
144 struct std_mono_table *t)
145{
146 int err;
147
148 while (t->name != NULL) {
149 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
150 t->cmask, t->val_type, t->name, t->tlv_callback);
151 if (err < 0)
152 return err;
153 t++;
154 }
155
156 return 0;
157}
158
159/*
Daniel Mack7b1eda22010-03-11 21:13:22 +0100160 * Sound Blaster remote control configuration
161 *
162 * format of remote control data:
163 * Extigy: xx 00
164 * Audigy 2 NX: 06 80 xx 00 00 00
165 * Live! 24-bit: 06 80 xx yy 22 83
166 */
167static const struct rc_config {
168 u32 usb_id;
169 u8 offset;
170 u8 length;
171 u8 packet_length;
172 u8 min_packet_length; /* minimum accepted length of the URB result */
173 u8 mute_mixer_id;
174 u32 mute_code;
175} rc_configs[] = {
176 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
177 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
178 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
Mandar Joshica8dc342010-11-02 14:43:19 +0000179 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
Mathieu Bouffard7cdd8d72011-05-18 17:09:17 +0200180 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
Daniel Mack7b1eda22010-03-11 21:13:22 +0100181 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
182};
183
184static void snd_usb_soundblaster_remote_complete(struct urb *urb)
185{
186 struct usb_mixer_interface *mixer = urb->context;
187 const struct rc_config *rc = mixer->rc_cfg;
188 u32 code;
189
190 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
191 return;
192
193 code = mixer->rc_buffer[rc->offset];
194 if (rc->length == 2)
195 code |= mixer->rc_buffer[rc->offset + 1] << 8;
196
197 /* the Mute button actually changes the mixer control */
198 if (code == rc->mute_code)
199 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
200 mixer->rc_code = code;
201 wmb();
202 wake_up(&mixer->rc_waitq);
203}
204
205static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
206 long count, loff_t *offset)
207{
208 struct usb_mixer_interface *mixer = hw->private_data;
209 int err;
210 u32 rc_code;
211
212 if (count != 1 && count != 4)
213 return -EINVAL;
214 err = wait_event_interruptible(mixer->rc_waitq,
215 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
216 if (err == 0) {
217 if (count == 1)
218 err = put_user(rc_code, buf);
219 else
220 err = put_user(rc_code, (u32 __user *)buf);
221 }
222 return err < 0 ? err : count;
223}
224
225static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
226 poll_table *wait)
227{
228 struct usb_mixer_interface *mixer = hw->private_data;
229
230 poll_wait(file, &mixer->rc_waitq, wait);
231 return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
232}
233
234static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
235{
236 struct snd_hwdep *hwdep;
237 int err, len, i;
238
239 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
240 if (rc_configs[i].usb_id == mixer->chip->usb_id)
241 break;
242 if (i >= ARRAY_SIZE(rc_configs))
243 return 0;
244 mixer->rc_cfg = &rc_configs[i];
245
246 len = mixer->rc_cfg->packet_length;
247
248 init_waitqueue_head(&mixer->rc_waitq);
249 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
250 if (err < 0)
251 return err;
252 snprintf(hwdep->name, sizeof(hwdep->name),
253 "%s remote control", mixer->chip->card->shortname);
254 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
255 hwdep->private_data = mixer;
256 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
257 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
258 hwdep->exclusive = 1;
259
260 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
261 if (!mixer->rc_urb)
262 return -ENOMEM;
263 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
264 if (!mixer->rc_setup_packet) {
265 usb_free_urb(mixer->rc_urb);
266 mixer->rc_urb = NULL;
267 return -ENOMEM;
268 }
269 mixer->rc_setup_packet->bRequestType =
270 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
271 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
272 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
273 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
274 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
275 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
276 usb_rcvctrlpipe(mixer->chip->dev, 0),
277 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
278 snd_usb_soundblaster_remote_complete, mixer);
279 return 0;
280}
281
282#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
283
284static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
285{
286 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
287 int index = kcontrol->private_value;
288
289 ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
290 return 0;
291}
292
293static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
294{
295 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
296 int index = kcontrol->private_value;
297 int value = ucontrol->value.integer.value[0];
298 int err, changed;
299
300 if (value > 1)
301 return -EINVAL;
302 changed = value != mixer->audigy2nx_leds[index];
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200303 down_read(&mixer->chip->shutdown_rwsem);
304 if (mixer->chip->shutdown) {
305 err = -ENODEV;
306 goto out;
307 }
Mandar Joshica8dc342010-11-02 14:43:19 +0000308 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3042))
309 err = snd_usb_ctl_msg(mixer->chip->dev,
310 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
311 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
Clemens Ladisch17d900c2011-09-26 21:15:27 +0200312 !value, 0, NULL, 0);
Mathieu Bouffard7cdd8d72011-05-18 17:09:17 +0200313 /* USB X-Fi S51 Pro */
314 if (mixer->chip->usb_id == USB_ID(0x041e, 0x30df))
315 err = snd_usb_ctl_msg(mixer->chip->dev,
316 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
317 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
Clemens Ladisch17d900c2011-09-26 21:15:27 +0200318 !value, 0, NULL, 0);
Mandar Joshica8dc342010-11-02 14:43:19 +0000319 else
320 err = snd_usb_ctl_msg(mixer->chip->dev,
Daniel Mack7b1eda22010-03-11 21:13:22 +0100321 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
322 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
Clemens Ladisch17d900c2011-09-26 21:15:27 +0200323 value, index + 2, NULL, 0);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200324 out:
325 up_read(&mixer->chip->shutdown_rwsem);
Daniel Mack7b1eda22010-03-11 21:13:22 +0100326 if (err < 0)
327 return err;
328 mixer->audigy2nx_leds[index] = value;
329 return changed;
330}
331
332static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
333 {
334 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
335 .name = "CMSS LED Switch",
336 .info = snd_audigy2nx_led_info,
337 .get = snd_audigy2nx_led_get,
338 .put = snd_audigy2nx_led_put,
339 .private_value = 0,
340 },
341 {
342 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
343 .name = "Power LED Switch",
344 .info = snd_audigy2nx_led_info,
345 .get = snd_audigy2nx_led_get,
346 .put = snd_audigy2nx_led_put,
347 .private_value = 1,
348 },
349 {
350 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
351 .name = "Dolby Digital LED Switch",
352 .info = snd_audigy2nx_led_info,
353 .get = snd_audigy2nx_led_get,
354 .put = snd_audigy2nx_led_put,
355 .private_value = 2,
356 },
357};
358
359static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
360{
361 int i, err;
362
363 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
Mandar Joshica8dc342010-11-02 14:43:19 +0000364 /* USB X-Fi S51 doesn't have a CMSS LED */
365 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
366 continue;
Mathieu Bouffard7cdd8d72011-05-18 17:09:17 +0200367 /* USB X-Fi S51 Pro doesn't have one either */
368 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
369 continue;
Daniel Mack7b1eda22010-03-11 21:13:22 +0100370 if (i > 1 && /* Live24ext has 2 LEDs only */
371 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
Mandar Joshica8dc342010-11-02 14:43:19 +0000372 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
Mathieu Bouffard7cdd8d72011-05-18 17:09:17 +0200373 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
Daniel Mack7b1eda22010-03-11 21:13:22 +0100374 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
375 break;
376 err = snd_ctl_add(mixer->chip->card,
377 snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
378 if (err < 0)
379 return err;
380 }
381 mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
382 return 0;
383}
384
385static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
386 struct snd_info_buffer *buffer)
387{
388 static const struct sb_jack {
389 int unitid;
390 const char *name;
391 } jacks_audigy2nx[] = {
392 {4, "dig in "},
393 {7, "line in"},
394 {19, "spk out"},
395 {20, "hph out"},
396 {-1, NULL}
397 }, jacks_live24ext[] = {
398 {4, "line in"}, /* &1=Line, &2=Mic*/
399 {3, "hph out"}, /* headphones */
400 {0, "RC "}, /* last command, 6 bytes see rc_config above */
401 {-1, NULL}
402 };
403 const struct sb_jack *jacks;
404 struct usb_mixer_interface *mixer = entry->private_data;
405 int i, err;
406 u8 buf[3];
407
408 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
409 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
410 jacks = jacks_audigy2nx;
411 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
412 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
413 jacks = jacks_live24ext;
414 else
415 return;
416
417 for (i = 0; jacks[i].name; ++i) {
418 snd_iprintf(buffer, "%s: ", jacks[i].name);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200419 down_read(&mixer->chip->shutdown_rwsem);
420 if (mixer->chip->shutdown)
421 err = 0;
422 else
423 err = snd_usb_ctl_msg(mixer->chip->dev,
Daniel Mack7b1eda22010-03-11 21:13:22 +0100424 usb_rcvctrlpipe(mixer->chip->dev, 0),
425 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
426 USB_RECIP_INTERFACE, 0,
Clemens Ladisch17d900c2011-09-26 21:15:27 +0200427 jacks[i].unitid << 8, buf, 3);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200428 up_read(&mixer->chip->shutdown_rwsem);
Daniel Mack7b1eda22010-03-11 21:13:22 +0100429 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
430 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
431 else
432 snd_iprintf(buffer, "?\n");
433 }
434}
435
Vasily Khoruzhick44832a72013-11-13 13:13:35 +0300436/* EMU0204 */
437static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
438 struct snd_ctl_elem_info *uinfo)
439{
440 static const char *texts[2] = {"1/2",
441 "3/4"
442 };
443
444 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
445 uinfo->count = 1;
446 uinfo->value.enumerated.items = 2;
447 if (uinfo->value.enumerated.item > 1)
448 uinfo->value.enumerated.item = 1;
449 strcpy(uinfo->value.enumerated.name,
450 texts[uinfo->value.enumerated.item]);
451
452 return 0;
453}
454
455static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
456 struct snd_ctl_elem_value *ucontrol)
457{
458 ucontrol->value.enumerated.item[0] = kcontrol->private_value;
459 return 0;
460}
461
462static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
463 struct snd_ctl_elem_value *ucontrol)
464{
465 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
466 unsigned int value = ucontrol->value.enumerated.item[0];
467 int err, changed;
468 unsigned char buf[2];
469
470 if (value > 1)
471 return -EINVAL;
472
473 buf[0] = 0x01;
474 buf[1] = value ? 0x02 : 0x01;
475
476 changed = value != kcontrol->private_value;
477 down_read(&mixer->chip->shutdown_rwsem);
478 if (mixer->chip->shutdown) {
479 err = -ENODEV;
480 goto out;
481 }
482 err = snd_usb_ctl_msg(mixer->chip->dev,
483 usb_sndctrlpipe(mixer->chip->dev, 0), UAC_SET_CUR,
484 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
485 0x0400, 0x0e00, buf, 2);
486 out:
487 up_read(&mixer->chip->shutdown_rwsem);
488 if (err < 0)
489 return err;
490 kcontrol->private_value = value;
491 return changed;
492}
493
494
495static struct snd_kcontrol_new snd_emu0204_controls[] = {
496 {
497 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
498 .name = "Front Jack Channels",
499 .info = snd_emu0204_ch_switch_info,
500 .get = snd_emu0204_ch_switch_get,
501 .put = snd_emu0204_ch_switch_put,
502 .private_value = 0,
503 },
504};
505
506static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
507{
508 int i, err;
509
510 for (i = 0; i < ARRAY_SIZE(snd_emu0204_controls); ++i) {
511 err = snd_ctl_add(mixer->chip->card,
512 snd_ctl_new1(&snd_emu0204_controls[i], mixer));
513 if (err < 0)
514 return err;
515 }
516
517 return 0;
518}
Denis Washington1d31aff2012-12-11 11:38:32 +0100519/* ASUS Xonar U1 / U3 controls */
520
Daniel Mack7b1eda22010-03-11 21:13:22 +0100521static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
522 struct snd_ctl_elem_value *ucontrol)
523{
524 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
525
526 ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
527 return 0;
528}
529
530static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
531 struct snd_ctl_elem_value *ucontrol)
532{
533 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
534 u8 old_status, new_status;
535 int err, changed;
536
537 old_status = mixer->xonar_u1_status;
538 if (ucontrol->value.integer.value[0])
539 new_status = old_status | 0x02;
540 else
541 new_status = old_status & ~0x02;
542 changed = new_status != old_status;
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200543 down_read(&mixer->chip->shutdown_rwsem);
544 if (mixer->chip->shutdown)
545 err = -ENODEV;
546 else
547 err = snd_usb_ctl_msg(mixer->chip->dev,
Daniel Mack7b1eda22010-03-11 21:13:22 +0100548 usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
549 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
Clemens Ladisch17d900c2011-09-26 21:15:27 +0200550 50, 0, &new_status, 1);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200551 up_read(&mixer->chip->shutdown_rwsem);
Daniel Mack7b1eda22010-03-11 21:13:22 +0100552 if (err < 0)
553 return err;
554 mixer->xonar_u1_status = new_status;
555 return changed;
556}
557
558static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
559 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
560 .name = "Digital Playback Switch",
561 .info = snd_ctl_boolean_mono_info,
562 .get = snd_xonar_u1_switch_get,
563 .put = snd_xonar_u1_switch_put,
564};
565
566static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
567{
568 int err;
569
570 err = snd_ctl_add(mixer->chip->card,
571 snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
572 if (err < 0)
573 return err;
574 mixer->xonar_u1_status = 0x05;
575 return 0;
576}
577
Daniel Mack54a8c502011-02-11 11:08:06 +0000578/* Native Instruments device quirks */
579
580#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
581
582static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
583 struct snd_ctl_elem_value *ucontrol)
584{
585 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
586 struct usb_device *dev = mixer->chip->dev;
587 u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
588 u16 wIndex = kcontrol->private_value & 0xffff;
589 u8 tmp;
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200590 int ret;
Daniel Mack54a8c502011-02-11 11:08:06 +0000591
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200592 down_read(&mixer->chip->shutdown_rwsem);
593 if (mixer->chip->shutdown)
594 ret = -ENODEV;
595 else
596 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
Daniel Mack54a8c502011-02-11 11:08:06 +0000597 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
Eldad Zack889d6682013-04-05 20:49:46 +0200598 0, wIndex,
Daniel Mack54a8c502011-02-11 11:08:06 +0000599 &tmp, sizeof(tmp), 1000);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200600 up_read(&mixer->chip->shutdown_rwsem);
Daniel Mack54a8c502011-02-11 11:08:06 +0000601
602 if (ret < 0) {
603 snd_printk(KERN_ERR
604 "unable to issue vendor read request (ret = %d)", ret);
605 return ret;
606 }
607
608 ucontrol->value.integer.value[0] = tmp;
609
610 return 0;
611}
612
613static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
614 struct snd_ctl_elem_value *ucontrol)
615{
616 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
617 struct usb_device *dev = mixer->chip->dev;
618 u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
619 u16 wIndex = kcontrol->private_value & 0xffff;
620 u16 wValue = ucontrol->value.integer.value[0];
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200621 int ret;
Daniel Mack54a8c502011-02-11 11:08:06 +0000622
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200623 down_read(&mixer->chip->shutdown_rwsem);
624 if (mixer->chip->shutdown)
625 ret = -ENODEV;
626 else
627 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), bRequest,
Daniel Mack54a8c502011-02-11 11:08:06 +0000628 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
Eldad Zack889d6682013-04-05 20:49:46 +0200629 wValue, wIndex,
Daniel Mack54a8c502011-02-11 11:08:06 +0000630 NULL, 0, 1000);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200631 up_read(&mixer->chip->shutdown_rwsem);
Daniel Mack54a8c502011-02-11 11:08:06 +0000632
633 if (ret < 0) {
634 snd_printk(KERN_ERR
635 "unable to issue vendor write request (ret = %d)", ret);
636 return ret;
637 }
638
639 return 0;
640}
641
642static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
643 {
644 .name = "Direct Thru Channel A",
645 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
646 },
647 {
648 .name = "Direct Thru Channel B",
649 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
650 },
651 {
652 .name = "Phono Input Channel A",
653 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
654 },
655 {
656 .name = "Phono Input Channel B",
657 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
658 },
659};
660
661static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
662 {
663 .name = "Direct Thru Channel A",
664 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
665 },
666 {
667 .name = "Direct Thru Channel B",
668 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
669 },
670 {
671 .name = "Direct Thru Channel C",
672 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
673 },
674 {
675 .name = "Direct Thru Channel D",
676 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
677 },
678 {
679 .name = "Phono Input Channel A",
680 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
681 },
682 {
683 .name = "Phono Input Channel B",
684 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
685 },
686 {
687 .name = "Phono Input Channel C",
688 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
689 },
690 {
691 .name = "Phono Input Channel D",
692 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
693 },
694};
695
696static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
697 const struct snd_kcontrol_new *kc,
698 unsigned int count)
699{
700 int i, err = 0;
701 struct snd_kcontrol_new template = {
702 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
703 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
704 .get = snd_nativeinstruments_control_get,
705 .put = snd_nativeinstruments_control_put,
706 .info = snd_ctl_boolean_mono_info,
707 };
708
709 for (i = 0; i < count; i++) {
710 struct snd_kcontrol *c;
711
712 template.name = kc[i].name;
713 template.private_value = kc[i].private_value;
714
715 c = snd_ctl_new1(&template, mixer);
716 err = snd_ctl_add(mixer->chip->card, c);
717
718 if (err < 0)
719 break;
720 }
721
722 return err;
723}
724
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200725/* M-Audio FastTrack Ultra quirks */
Matt Gruskine9a25e02013-02-09 12:56:35 -0500726/* FTU Effect switch (also used by C400/C600) */
Felix Homannd34bf142012-04-23 20:24:27 +0200727struct snd_ftu_eff_switch_priv_val {
728 struct usb_mixer_interface *mixer;
729 int cached_value;
730 int is_cached;
Eldad Zackd847ce02012-11-28 23:55:37 +0100731 int bUnitID;
732 int validx;
Felix Homannd34bf142012-04-23 20:24:27 +0200733};
734
735static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
736 struct snd_ctl_elem_info *uinfo)
737{
738 static const char *texts[8] = {"Room 1",
739 "Room 2",
740 "Room 3",
741 "Hall 1",
742 "Hall 2",
743 "Plate",
744 "Delay",
745 "Echo"
746 };
747
748 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
749 uinfo->count = 1;
750 uinfo->value.enumerated.items = 8;
751 if (uinfo->value.enumerated.item > 7)
752 uinfo->value.enumerated.item = 7;
753 strcpy(uinfo->value.enumerated.name,
754 texts[uinfo->value.enumerated.item]);
755
756 return 0;
757}
758
759static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
760 struct snd_ctl_elem_value *ucontrol)
761{
762 struct snd_usb_audio *chip;
763 struct usb_mixer_interface *mixer;
764 struct snd_ftu_eff_switch_priv_val *pval;
765 int err;
766 unsigned char value[2];
Eldad Zackd847ce02012-11-28 23:55:37 +0100767 int id, validx;
Felix Homannd34bf142012-04-23 20:24:27 +0200768
Felix Homannd34bf142012-04-23 20:24:27 +0200769 const int val_len = 2;
770
771 value[0] = 0x00;
772 value[1] = 0x00;
773
774 pval = (struct snd_ftu_eff_switch_priv_val *)
775 kctl->private_value;
776
777 if (pval->is_cached) {
778 ucontrol->value.enumerated.item[0] = pval->cached_value;
779 return 0;
780 }
781
782 mixer = (struct usb_mixer_interface *) pval->mixer;
783 if (snd_BUG_ON(!mixer))
784 return -EINVAL;
785
786 chip = (struct snd_usb_audio *) mixer->chip;
787 if (snd_BUG_ON(!chip))
788 return -EINVAL;
789
Eldad Zackd847ce02012-11-28 23:55:37 +0100790 id = pval->bUnitID;
791 validx = pval->validx;
Felix Homannd34bf142012-04-23 20:24:27 +0200792
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200793 down_read(&mixer->chip->shutdown_rwsem);
794 if (mixer->chip->shutdown)
795 err = -ENODEV;
796 else
797 err = snd_usb_ctl_msg(chip->dev,
Felix Homannd34bf142012-04-23 20:24:27 +0200798 usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
799 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
800 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
801 value, val_len);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200802 up_read(&mixer->chip->shutdown_rwsem);
Felix Homannd34bf142012-04-23 20:24:27 +0200803 if (err < 0)
804 return err;
805
806 ucontrol->value.enumerated.item[0] = value[0];
807 pval->cached_value = value[0];
808 pval->is_cached = 1;
809
810 return 0;
811}
812
813static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
814 struct snd_ctl_elem_value *ucontrol)
815{
816 struct snd_usb_audio *chip;
817 struct snd_ftu_eff_switch_priv_val *pval;
818
819 struct usb_mixer_interface *mixer;
820 int changed, cur_val, err, new_val;
821 unsigned char value[2];
Eldad Zackd847ce02012-11-28 23:55:37 +0100822 int id, validx;
Felix Homannd34bf142012-04-23 20:24:27 +0200823
Felix Homannd34bf142012-04-23 20:24:27 +0200824 const int val_len = 2;
825
826 changed = 0;
827
828 pval = (struct snd_ftu_eff_switch_priv_val *)
829 kctl->private_value;
830 cur_val = pval->cached_value;
831 new_val = ucontrol->value.enumerated.item[0];
832
833 mixer = (struct usb_mixer_interface *) pval->mixer;
834 if (snd_BUG_ON(!mixer))
835 return -EINVAL;
836
837 chip = (struct snd_usb_audio *) mixer->chip;
838 if (snd_BUG_ON(!chip))
839 return -EINVAL;
840
Eldad Zackd847ce02012-11-28 23:55:37 +0100841 id = pval->bUnitID;
842 validx = pval->validx;
843
Felix Homannd34bf142012-04-23 20:24:27 +0200844 if (!pval->is_cached) {
845 /* Read current value */
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200846 down_read(&mixer->chip->shutdown_rwsem);
847 if (mixer->chip->shutdown)
848 err = -ENODEV;
849 else
850 err = snd_usb_ctl_msg(chip->dev,
Felix Homannd34bf142012-04-23 20:24:27 +0200851 usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
852 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
853 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
854 value, val_len);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200855 up_read(&mixer->chip->shutdown_rwsem);
Felix Homannd34bf142012-04-23 20:24:27 +0200856 if (err < 0)
857 return err;
858
859 cur_val = value[0];
860 pval->cached_value = cur_val;
861 pval->is_cached = 1;
862 }
863 /* update value if needed */
864 if (cur_val != new_val) {
865 value[0] = new_val;
866 value[1] = 0;
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200867 down_read(&mixer->chip->shutdown_rwsem);
868 if (mixer->chip->shutdown)
869 err = -ENODEV;
870 else
871 err = snd_usb_ctl_msg(chip->dev,
Felix Homannd34bf142012-04-23 20:24:27 +0200872 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
873 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
874 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
875 value, val_len);
Takashi Iwai888ea7d2012-10-15 12:40:37 +0200876 up_read(&mixer->chip->shutdown_rwsem);
Felix Homannd34bf142012-04-23 20:24:27 +0200877 if (err < 0)
878 return err;
879
880 pval->cached_value = new_val;
881 pval->is_cached = 1;
882 changed = 1;
883 }
884
885 return changed;
886}
887
Eldad Zackd847ce02012-11-28 23:55:37 +0100888static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
889 int validx, int bUnitID)
Felix Homannd34bf142012-04-23 20:24:27 +0200890{
891 static struct snd_kcontrol_new template = {
892 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
893 .name = "Effect Program Switch",
894 .index = 0,
895 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
896 .info = snd_ftu_eff_switch_info,
897 .get = snd_ftu_eff_switch_get,
898 .put = snd_ftu_eff_switch_put
899 };
900
901 int err;
902 struct snd_kcontrol *kctl;
903 struct snd_ftu_eff_switch_priv_val *pval;
904
905 pval = kzalloc(sizeof(*pval), GFP_KERNEL);
906 if (!pval)
907 return -ENOMEM;
908
909 pval->cached_value = 0;
910 pval->is_cached = 0;
911 pval->mixer = mixer;
Eldad Zackd847ce02012-11-28 23:55:37 +0100912 pval->bUnitID = bUnitID;
913 pval->validx = validx;
Felix Homannd34bf142012-04-23 20:24:27 +0200914
915 template.private_value = (unsigned long) pval;
916 kctl = snd_ctl_new1(&template, mixer->chip);
917 if (!kctl) {
918 kfree(pval);
919 return -ENOMEM;
920 }
921
922 err = snd_ctl_add(mixer->chip->card, kctl);
923 if (err < 0)
924 return err;
925
926 return 0;
927}
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200928
Felix Homanncfe8f972012-04-23 20:24:26 +0200929/* Create volume controls for FTU devices*/
930static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200931{
932 char name[64];
Felix Homann8a4d1d32012-04-23 20:24:23 +0200933 unsigned int control, cmask;
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200934 int in, out, err;
935
Felix Homann8a4d1d32012-04-23 20:24:23 +0200936 const unsigned int id = 5;
937 const int val_type = USB_MIXER_S16;
938
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200939 for (out = 0; out < 8; out++) {
Felix Homann8a4d1d32012-04-23 20:24:23 +0200940 control = out + 1;
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200941 for (in = 0; in < 8; in++) {
Felix Homann8a4d1d32012-04-23 20:24:23 +0200942 cmask = 1 << in;
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200943 snprintf(name, sizeof(name),
Felix Homann8a4d1d32012-04-23 20:24:23 +0200944 "AIn%d - Out%d Capture Volume",
945 in + 1, out + 1);
946 err = snd_create_std_mono_ctl(mixer, id, control,
947 cmask, val_type, name,
Felix Homann25ee7ef2012-04-23 20:24:25 +0200948 &snd_usb_mixer_vol_tlv);
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200949 if (err < 0)
950 return err;
951 }
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200952 for (in = 8; in < 16; in++) {
Felix Homann8a4d1d32012-04-23 20:24:23 +0200953 cmask = 1 << in;
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200954 snprintf(name, sizeof(name),
Felix Homann8a4d1d32012-04-23 20:24:23 +0200955 "DIn%d - Out%d Playback Volume",
956 in - 7, out + 1);
957 err = snd_create_std_mono_ctl(mixer, id, control,
958 cmask, val_type, name,
Felix Homann25ee7ef2012-04-23 20:24:25 +0200959 &snd_usb_mixer_vol_tlv);
Daniel Mackd5a0bf62011-05-25 09:09:03 +0200960 if (err < 0)
961 return err;
962 }
963 }
964
965 return 0;
966}
967
Felix Homannd34bf142012-04-23 20:24:27 +0200968/* This control needs a volume quirk, see mixer.c */
969static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
970{
971 static const char name[] = "Effect Volume";
972 const unsigned int id = 6;
973 const int val_type = USB_MIXER_U8;
974 const unsigned int control = 2;
975 const unsigned int cmask = 0;
976
977 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
978 name, snd_usb_mixer_vol_tlv);
979}
980
981/* This control needs a volume quirk, see mixer.c */
982static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
983{
984 static const char name[] = "Effect Duration";
985 const unsigned int id = 6;
986 const int val_type = USB_MIXER_S16;
987 const unsigned int control = 3;
988 const unsigned int cmask = 0;
989
990 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
991 name, snd_usb_mixer_vol_tlv);
992}
993
994/* This control needs a volume quirk, see mixer.c */
995static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
996{
997 static const char name[] = "Effect Feedback Volume";
998 const unsigned int id = 6;
999 const int val_type = USB_MIXER_U8;
1000 const unsigned int control = 4;
1001 const unsigned int cmask = 0;
1002
1003 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1004 name, NULL);
1005}
1006
1007static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1008{
1009 unsigned int cmask;
1010 int err, ch;
1011 char name[48];
1012
1013 const unsigned int id = 7;
1014 const int val_type = USB_MIXER_S16;
1015 const unsigned int control = 7;
1016
1017 for (ch = 0; ch < 4; ++ch) {
1018 cmask = 1 << ch;
1019 snprintf(name, sizeof(name),
1020 "Effect Return %d Volume", ch + 1);
1021 err = snd_create_std_mono_ctl(mixer, id, control,
1022 cmask, val_type, name,
1023 snd_usb_mixer_vol_tlv);
1024 if (err < 0)
1025 return err;
1026 }
1027
1028 return 0;
1029}
1030
1031static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1032{
1033 unsigned int cmask;
1034 int err, ch;
1035 char name[48];
1036
1037 const unsigned int id = 5;
1038 const int val_type = USB_MIXER_S16;
1039 const unsigned int control = 9;
1040
1041 for (ch = 0; ch < 8; ++ch) {
1042 cmask = 1 << ch;
1043 snprintf(name, sizeof(name),
1044 "Effect Send AIn%d Volume", ch + 1);
1045 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1046 val_type, name,
1047 snd_usb_mixer_vol_tlv);
1048 if (err < 0)
1049 return err;
1050 }
1051 for (ch = 8; ch < 16; ++ch) {
1052 cmask = 1 << ch;
1053 snprintf(name, sizeof(name),
1054 "Effect Send DIn%d Volume", ch - 7);
1055 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1056 val_type, name,
1057 snd_usb_mixer_vol_tlv);
1058 if (err < 0)
1059 return err;
1060 }
1061 return 0;
1062}
1063
Felix Homanncfe8f972012-04-23 20:24:26 +02001064static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
Mark Hills7536c302012-04-14 17:19:24 +01001065{
Felix Homann8a4d1d32012-04-23 20:24:23 +02001066 int err;
Mark Hills7536c302012-04-14 17:19:24 +01001067
Felix Homanncfe8f972012-04-23 20:24:26 +02001068 err = snd_ftu_create_volume_ctls(mixer);
Felix Homann8a4d1d32012-04-23 20:24:23 +02001069 if (err < 0)
1070 return err;
Mark Hills7536c302012-04-14 17:19:24 +01001071
Eldad Zackd847ce02012-11-28 23:55:37 +01001072 err = snd_ftu_create_effect_switch(mixer, 1, 6);
Felix Homannd34bf142012-04-23 20:24:27 +02001073 if (err < 0)
1074 return err;
Eldad Zackd847ce02012-11-28 23:55:37 +01001075
Felix Homannd34bf142012-04-23 20:24:27 +02001076 err = snd_ftu_create_effect_volume_ctl(mixer);
1077 if (err < 0)
1078 return err;
1079
1080 err = snd_ftu_create_effect_duration_ctl(mixer);
1081 if (err < 0)
1082 return err;
1083
1084 err = snd_ftu_create_effect_feedback_ctl(mixer);
1085 if (err < 0)
1086 return err;
1087
1088 err = snd_ftu_create_effect_return_ctls(mixer);
1089 if (err < 0)
1090 return err;
1091
1092 err = snd_ftu_create_effect_send_ctls(mixer);
1093 if (err < 0)
1094 return err;
1095
Felix Homann8a4d1d32012-04-23 20:24:23 +02001096 return 0;
Mark Hills7536c302012-04-14 17:19:24 +01001097}
1098
Daniel Mack7b1eda22010-03-11 21:13:22 +01001099void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1100 unsigned char samplerate_id)
1101{
1102 struct usb_mixer_interface *mixer;
1103 struct usb_mixer_elem_info *cval;
1104 int unitid = 12; /* SamleRate ExtensionUnit ID */
1105
1106 list_for_each_entry(mixer, &chip->mixer_list, list) {
1107 cval = mixer->id_elems[unitid];
1108 if (cval) {
1109 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1110 cval->control << 8,
1111 samplerate_id);
1112 snd_usb_mixer_notify_id(mixer, unitid);
1113 }
1114 break;
1115 }
1116}
1117
Matt Gruskine9a25e02013-02-09 12:56:35 -05001118/* M-Audio Fast Track C400/C600 */
1119/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001120static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1121{
1122 char name[64];
1123 unsigned int cmask, offset;
1124 int out, chan, err;
Matt Gruskine9a25e02013-02-09 12:56:35 -05001125 int num_outs = 0;
1126 int num_ins = 0;
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001127
1128 const unsigned int id = 0x40;
1129 const int val_type = USB_MIXER_S16;
1130 const int control = 1;
1131
Matt Gruskine9a25e02013-02-09 12:56:35 -05001132 switch (mixer->chip->usb_id) {
1133 case USB_ID(0x0763, 0x2030):
1134 num_outs = 6;
1135 num_ins = 4;
1136 break;
1137 case USB_ID(0x0763, 0x2031):
1138 num_outs = 8;
1139 num_ins = 6;
1140 break;
1141 }
1142
1143 for (chan = 0; chan < num_outs + num_ins; chan++) {
1144 for (out = 0; out < num_outs; out++) {
1145 if (chan < num_outs) {
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001146 snprintf(name, sizeof(name),
1147 "PCM%d-Out%d Playback Volume",
1148 chan + 1, out + 1);
1149 } else {
1150 snprintf(name, sizeof(name),
1151 "In%d-Out%d Playback Volume",
Matt Gruskine9a25e02013-02-09 12:56:35 -05001152 chan - num_outs + 1, out + 1);
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001153 }
1154
1155 cmask = (out == 0) ? 0 : 1 << (out - 1);
Matt Gruskine9a25e02013-02-09 12:56:35 -05001156 offset = chan * num_outs;
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001157 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1158 cmask, val_type, offset, name,
1159 &snd_usb_mixer_vol_tlv);
1160 if (err < 0)
1161 return err;
1162 }
1163 }
1164
1165 return 0;
1166}
1167
1168/* This control needs a volume quirk, see mixer.c */
1169static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1170{
1171 static const char name[] = "Effect Volume";
1172 const unsigned int id = 0x43;
1173 const int val_type = USB_MIXER_U8;
1174 const unsigned int control = 3;
1175 const unsigned int cmask = 0;
1176
1177 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1178 name, snd_usb_mixer_vol_tlv);
1179}
1180
1181/* This control needs a volume quirk, see mixer.c */
1182static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1183{
1184 static const char name[] = "Effect Duration";
1185 const unsigned int id = 0x43;
1186 const int val_type = USB_MIXER_S16;
1187 const unsigned int control = 4;
1188 const unsigned int cmask = 0;
1189
1190 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1191 name, snd_usb_mixer_vol_tlv);
1192}
1193
1194/* This control needs a volume quirk, see mixer.c */
1195static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1196{
1197 static const char name[] = "Effect Feedback Volume";
1198 const unsigned int id = 0x43;
1199 const int val_type = USB_MIXER_U8;
1200 const unsigned int control = 5;
1201 const unsigned int cmask = 0;
1202
1203 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1204 name, NULL);
1205}
1206
1207static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1208{
1209 char name[64];
1210 unsigned int cmask;
1211 int chan, err;
Matt Gruskine9a25e02013-02-09 12:56:35 -05001212 int num_outs = 0;
1213 int num_ins = 0;
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001214
1215 const unsigned int id = 0x42;
1216 const int val_type = USB_MIXER_S16;
1217 const int control = 1;
1218
Matt Gruskine9a25e02013-02-09 12:56:35 -05001219 switch (mixer->chip->usb_id) {
1220 case USB_ID(0x0763, 0x2030):
1221 num_outs = 6;
1222 num_ins = 4;
1223 break;
1224 case USB_ID(0x0763, 0x2031):
1225 num_outs = 8;
1226 num_ins = 6;
1227 break;
1228 }
1229
1230 for (chan = 0; chan < num_outs + num_ins; chan++) {
1231 if (chan < num_outs) {
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001232 snprintf(name, sizeof(name),
1233 "Effect Send DOut%d",
1234 chan + 1);
1235 } else {
1236 snprintf(name, sizeof(name),
1237 "Effect Send AIn%d",
Matt Gruskine9a25e02013-02-09 12:56:35 -05001238 chan - num_outs + 1);
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001239 }
1240
1241 cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1242 err = snd_create_std_mono_ctl(mixer, id, control,
1243 cmask, val_type, name,
1244 &snd_usb_mixer_vol_tlv);
1245 if (err < 0)
1246 return err;
1247 }
1248
1249 return 0;
1250}
1251
1252static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1253{
1254 char name[64];
1255 unsigned int cmask;
1256 int chan, err;
Matt Gruskine9a25e02013-02-09 12:56:35 -05001257 int num_outs = 0;
1258 int offset = 0;
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001259
1260 const unsigned int id = 0x40;
1261 const int val_type = USB_MIXER_S16;
1262 const int control = 1;
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001263
Matt Gruskine9a25e02013-02-09 12:56:35 -05001264 switch (mixer->chip->usb_id) {
1265 case USB_ID(0x0763, 0x2030):
1266 num_outs = 6;
1267 offset = 0x3c;
1268 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1269 break;
1270 case USB_ID(0x0763, 0x2031):
1271 num_outs = 8;
1272 offset = 0x70;
1273 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1274 break;
1275 }
1276
1277 for (chan = 0; chan < num_outs; chan++) {
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001278 snprintf(name, sizeof(name),
1279 "Effect Return %d",
1280 chan + 1);
1281
Matt Gruskine9a25e02013-02-09 12:56:35 -05001282 cmask = (chan == 0) ? 0 :
1283 1 << (chan + (chan % 2) * num_outs - 1);
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001284 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1285 cmask, val_type, offset, name,
1286 &snd_usb_mixer_vol_tlv);
1287 if (err < 0)
1288 return err;
1289 }
1290
1291 return 0;
1292}
1293
1294static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1295{
1296 int err;
1297
1298 err = snd_c400_create_vol_ctls(mixer);
1299 if (err < 0)
1300 return err;
1301
1302 err = snd_c400_create_effect_vol_ctls(mixer);
1303 if (err < 0)
1304 return err;
1305
1306 err = snd_c400_create_effect_ret_vol_ctls(mixer);
1307 if (err < 0)
1308 return err;
1309
1310 err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1311 if (err < 0)
1312 return err;
1313
1314 err = snd_c400_create_effect_volume_ctl(mixer);
1315 if (err < 0)
1316 return err;
1317
1318 err = snd_c400_create_effect_duration_ctl(mixer);
1319 if (err < 0)
1320 return err;
1321
1322 err = snd_c400_create_effect_feedback_ctl(mixer);
1323 if (err < 0)
1324 return err;
1325
1326 return 0;
1327}
1328
Mark Hillsb71dad182012-06-09 13:16:38 +01001329/*
1330 * The mixer units for Ebox-44 are corrupt, and even where they
1331 * are valid they presents mono controls as L and R channels of
1332 * stereo. So we provide a good mixer here.
1333 */
Sachin Kamate8e7da22013-01-10 11:19:14 +05301334static struct std_mono_table ebox44_table[] = {
Mark Hills989b0132012-06-09 13:16:39 +01001335 {
1336 .unitid = 4,
1337 .control = 1,
1338 .cmask = 0x0,
1339 .val_type = USB_MIXER_INV_BOOLEAN,
1340 .name = "Headphone Playback Switch"
1341 },
1342 {
1343 .unitid = 4,
1344 .control = 2,
1345 .cmask = 0x1,
1346 .val_type = USB_MIXER_S16,
1347 .name = "Headphone A Mix Playback Volume"
1348 },
1349 {
1350 .unitid = 4,
1351 .control = 2,
1352 .cmask = 0x2,
1353 .val_type = USB_MIXER_S16,
1354 .name = "Headphone B Mix Playback Volume"
1355 },
Mark Hillsb71dad182012-06-09 13:16:38 +01001356
Mark Hills989b0132012-06-09 13:16:39 +01001357 {
1358 .unitid = 7,
1359 .control = 1,
1360 .cmask = 0x0,
1361 .val_type = USB_MIXER_INV_BOOLEAN,
1362 .name = "Output Playback Switch"
1363 },
1364 {
1365 .unitid = 7,
1366 .control = 2,
1367 .cmask = 0x1,
1368 .val_type = USB_MIXER_S16,
1369 .name = "Output A Playback Volume"
1370 },
1371 {
1372 .unitid = 7,
1373 .control = 2,
1374 .cmask = 0x2,
1375 .val_type = USB_MIXER_S16,
1376 .name = "Output B Playback Volume"
1377 },
Mark Hillsb71dad182012-06-09 13:16:38 +01001378
Mark Hills989b0132012-06-09 13:16:39 +01001379 {
1380 .unitid = 10,
1381 .control = 1,
1382 .cmask = 0x0,
1383 .val_type = USB_MIXER_INV_BOOLEAN,
1384 .name = "Input Capture Switch"
1385 },
1386 {
1387 .unitid = 10,
1388 .control = 2,
1389 .cmask = 0x1,
1390 .val_type = USB_MIXER_S16,
1391 .name = "Input A Capture Volume"
1392 },
1393 {
1394 .unitid = 10,
1395 .control = 2,
1396 .cmask = 0x2,
1397 .val_type = USB_MIXER_S16,
1398 .name = "Input B Capture Volume"
1399 },
Mark Hillsb71dad182012-06-09 13:16:38 +01001400
Mark Hills989b0132012-06-09 13:16:39 +01001401 {}
Mark Hillsb71dad182012-06-09 13:16:38 +01001402};
1403
Przemek Rudy066624c2013-06-27 23:52:33 +02001404/* Audio Advantage Micro II findings:
1405 *
1406 * Mapping spdif AES bits to vendor register.bit:
1407 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1408 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1409 * AES2: [0 0 0 0 0 0 0 0]
1410 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1411 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1412 *
1413 * power on values:
1414 * r2: 0x10
1415 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1416 * just after it to 0xa0, presumably it disables/mutes some analog
1417 * parts when there is no audio.)
1418 * r9: 0x28
1419 *
1420 * Optical transmitter on/off:
1421 * vendor register.bit: 9.1
1422 * 0 - on (0x28 register value)
1423 * 1 - off (0x2a register value)
1424 *
1425 */
1426static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1427 struct snd_ctl_elem_info *uinfo)
1428{
1429 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1430 uinfo->count = 1;
1431 return 0;
1432}
1433
1434static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1435 struct snd_ctl_elem_value *ucontrol)
1436{
1437 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
1438 int err;
1439 struct usb_interface *iface;
1440 struct usb_host_interface *alts;
1441 unsigned int ep;
1442 unsigned char data[3];
1443 int rate;
1444
1445 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1446 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1447 ucontrol->value.iec958.status[2] = 0x00;
1448
1449 /* use known values for that card: interface#1 altsetting#1 */
1450 iface = usb_ifnum_to_if(mixer->chip->dev, 1);
1451 alts = &iface->altsetting[1];
1452 ep = get_endpoint(alts, 0)->bEndpointAddress;
1453
1454 err = snd_usb_ctl_msg(mixer->chip->dev,
1455 usb_rcvctrlpipe(mixer->chip->dev, 0),
1456 UAC_GET_CUR,
1457 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1458 UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1459 ep,
1460 data,
1461 sizeof(data));
1462 if (err < 0)
1463 goto end;
1464
1465 rate = data[0] | (data[1] << 8) | (data[2] << 16);
1466 ucontrol->value.iec958.status[3] = (rate == 48000) ?
1467 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1468
1469 err = 0;
1470end:
1471 return err;
1472}
1473
1474static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1475 struct snd_ctl_elem_value *ucontrol)
1476{
1477 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
1478 int err;
1479 u8 reg;
1480 unsigned long priv_backup = kcontrol->private_value;
1481
1482 reg = ((ucontrol->value.iec958.status[1] & 0x0f) << 4) |
1483 (ucontrol->value.iec958.status[0] & 0x0f);
1484 err = snd_usb_ctl_msg(mixer->chip->dev,
1485 usb_sndctrlpipe(mixer->chip->dev, 0),
1486 UAC_SET_CUR,
1487 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1488 reg,
1489 2,
1490 NULL,
1491 0);
1492 if (err < 0)
1493 goto end;
1494
1495 kcontrol->private_value &= 0xfffff0f0;
1496 kcontrol->private_value |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1497 kcontrol->private_value |= (ucontrol->value.iec958.status[0] & 0x0f);
1498
1499 reg = (ucontrol->value.iec958.status[0] & IEC958_AES0_NONAUDIO) ?
1500 0xa0 : 0x20;
1501 reg |= (ucontrol->value.iec958.status[1] >> 4) & 0x0f;
1502 err = snd_usb_ctl_msg(mixer->chip->dev,
1503 usb_sndctrlpipe(mixer->chip->dev, 0),
1504 UAC_SET_CUR,
1505 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1506 reg,
1507 3,
1508 NULL,
1509 0);
1510 if (err < 0)
1511 goto end;
1512
1513 kcontrol->private_value &= 0xffff0fff;
1514 kcontrol->private_value |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1515
1516 /* The frequency bits in AES3 cannot be set via register access. */
1517
1518 /* Silently ignore any bits from the request that cannot be set. */
1519
1520 err = (priv_backup != kcontrol->private_value);
1521end:
1522 return err;
1523}
1524
1525static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1526 struct snd_ctl_elem_value *ucontrol)
1527{
1528 ucontrol->value.iec958.status[0] = 0x0f;
1529 ucontrol->value.iec958.status[1] = 0xff;
1530 ucontrol->value.iec958.status[2] = 0x00;
1531 ucontrol->value.iec958.status[3] = 0x00;
1532
1533 return 0;
1534}
1535
1536static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1537 struct snd_ctl_elem_value *ucontrol)
1538{
1539 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1540
1541 return 0;
1542}
1543
1544static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1545 struct snd_ctl_elem_value *ucontrol)
1546{
1547 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
1548 int err;
1549 u8 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1550
1551 err = snd_usb_ctl_msg(mixer->chip->dev,
1552 usb_sndctrlpipe(mixer->chip->dev, 0),
1553 UAC_SET_CUR,
1554 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1555 reg,
1556 9,
1557 NULL,
1558 0);
1559
1560 if (!err) {
1561 err = (reg != (kcontrol->private_value & 0x0ff));
1562 if (err)
1563 kcontrol->private_value = reg;
1564 }
1565
1566 return err;
1567}
1568
1569static struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1570 {
1571 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1572 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1573 .info = snd_microii_spdif_info,
1574 .get = snd_microii_spdif_default_get,
1575 .put = snd_microii_spdif_default_put,
1576 .private_value = 0x00000100UL,/* reset value */
1577 },
1578 {
1579 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1580 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1581 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1582 .info = snd_microii_spdif_info,
1583 .get = snd_microii_spdif_mask_get,
1584 },
1585 {
1586 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1587 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1588 .info = snd_ctl_boolean_mono_info,
1589 .get = snd_microii_spdif_switch_get,
1590 .put = snd_microii_spdif_switch_put,
1591 .private_value = 0x00000028UL,/* reset value */
1592 }
1593};
1594
1595static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1596{
1597 int err, i;
1598
1599 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1600 err = snd_ctl_add(mixer->chip->card,
1601 snd_ctl_new1(&snd_microii_mixer_spdif[i], mixer));
1602 if (err < 0)
1603 return err;
1604 }
1605
Mikulas Patocka18e47532013-12-05 14:32:43 -05001606 return 0;
Przemek Rudy066624c2013-06-27 23:52:33 +02001607}
1608
Daniel Mack7b1eda22010-03-11 21:13:22 +01001609int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
1610{
Daniel Mack3347b262011-02-11 11:34:12 +00001611 int err = 0;
Daniel Mack7b1eda22010-03-11 21:13:22 +01001612 struct snd_info_entry *entry;
1613
1614 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
1615 return err;
1616
Daniel Mack3347b262011-02-11 11:34:12 +00001617 switch (mixer->chip->usb_id) {
1618 case USB_ID(0x041e, 0x3020):
1619 case USB_ID(0x041e, 0x3040):
1620 case USB_ID(0x041e, 0x3042):
Mathieu Bouffard7cdd8d72011-05-18 17:09:17 +02001621 case USB_ID(0x041e, 0x30df):
Daniel Mack3347b262011-02-11 11:34:12 +00001622 case USB_ID(0x041e, 0x3048):
1623 err = snd_audigy2nx_controls_create(mixer);
1624 if (err < 0)
1625 break;
Daniel Mack7b1eda22010-03-11 21:13:22 +01001626 if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
1627 snd_info_set_text_ops(entry, mixer,
1628 snd_audigy2nx_proc_read);
Daniel Mack3347b262011-02-11 11:34:12 +00001629 break;
Daniel Mack7b1eda22010-03-11 21:13:22 +01001630
Vasily Khoruzhick44832a72013-11-13 13:13:35 +03001631 /* EMU0204 */
1632 case USB_ID(0x041e, 0x3f19):
1633 err = snd_emu0204_controls_create(mixer);
1634 if (err < 0)
1635 break;
1636 break;
1637
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001638 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
Matt Gruskine9a25e02013-02-09 12:56:35 -05001639 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
Eldad Zack09d8e3a2012-11-28 23:55:40 +01001640 err = snd_c400_create_mixer(mixer);
1641 break;
1642
Daniel Mackd5a0bf62011-05-25 09:09:03 +02001643 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
1644 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
Felix Homanncfe8f972012-04-23 20:24:26 +02001645 err = snd_ftu_create_mixer(mixer);
Daniel Mackd5a0bf62011-05-25 09:09:03 +02001646 break;
1647
Denis Washington1d31aff2012-12-11 11:38:32 +01001648 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
1649 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
1650 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
Daniel Mack7b1eda22010-03-11 21:13:22 +01001651 err = snd_xonar_u1_controls_create(mixer);
Daniel Mack3347b262011-02-11 11:34:12 +00001652 break;
Daniel Mack7b1eda22010-03-11 21:13:22 +01001653
Przemek Rudy066624c2013-06-27 23:52:33 +02001654 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
1655 err = snd_microii_controls_create(mixer);
1656 break;
1657
Daniel Mack3347b262011-02-11 11:34:12 +00001658 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
Daniel Mack54a8c502011-02-11 11:08:06 +00001659 err = snd_nativeinstruments_create_mixer(mixer,
1660 snd_nativeinstruments_ta6_mixers,
1661 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
Daniel Mack3347b262011-02-11 11:34:12 +00001662 break;
Daniel Mack54a8c502011-02-11 11:08:06 +00001663
Daniel Mack3347b262011-02-11 11:34:12 +00001664 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
Daniel Mack54a8c502011-02-11 11:08:06 +00001665 err = snd_nativeinstruments_create_mixer(mixer,
1666 snd_nativeinstruments_ta10_mixers,
1667 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
Daniel Mack3347b262011-02-11 11:34:12 +00001668 break;
Mark Hills7536c302012-04-14 17:19:24 +01001669
1670 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
Mark Hillsb71dad182012-06-09 13:16:38 +01001671 /* detection is disabled in mixer_maps.c */
1672 err = snd_create_std_mono_table(mixer, ebox44_table);
Mark Hills7536c302012-04-14 17:19:24 +01001673 break;
Daniel Mack54a8c502011-02-11 11:08:06 +00001674 }
1675
Daniel Mack3347b262011-02-11 11:34:12 +00001676 return err;
Daniel Mack7b1eda22010-03-11 21:13:22 +01001677}
1678
1679void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
1680 int unitid)
1681{
1682 if (!mixer->rc_cfg)
1683 return;
1684 /* unit ids specific to Extigy/Audigy 2 NX: */
1685 switch (unitid) {
1686 case 0: /* remote control */
1687 mixer->rc_urb->dev = mixer->chip->dev;
1688 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
1689 break;
1690 case 4: /* digital in jack */
1691 case 7: /* line in jacks */
1692 case 19: /* speaker out jacks */
1693 case 20: /* headphones out jack */
1694 break;
1695 /* live24ext: 4 = line-in jack */
1696 case 3: /* hp-out jack (may actuate Mute) */
1697 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
1698 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
1699 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
1700 break;
1701 default:
1702 snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
1703 break;
1704 }
1705}
1706