Loading...
1/*
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 *
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28#include <linux/init.h>
29#include <linux/slab.h>
30#include <linux/usb.h>
31#include <linux/usb/audio.h>
32
33#include <sound/core.h>
34#include <sound/control.h>
35#include <sound/hwdep.h>
36#include <sound/info.h>
37
38#include "usbaudio.h"
39#include "mixer.h"
40#include "mixer_quirks.h"
41#include "helper.h"
42
43extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;
44
45/*
46 * Sound Blaster remote control configuration
47 *
48 * format of remote control data:
49 * Extigy: xx 00
50 * Audigy 2 NX: 06 80 xx 00 00 00
51 * Live! 24-bit: 06 80 xx yy 22 83
52 */
53static const struct rc_config {
54 u32 usb_id;
55 u8 offset;
56 u8 length;
57 u8 packet_length;
58 u8 min_packet_length; /* minimum accepted length of the URB result */
59 u8 mute_mixer_id;
60 u32 mute_code;
61} rc_configs[] = {
62 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
63 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
64 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
65 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
66 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
67 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
68};
69
70static void snd_usb_soundblaster_remote_complete(struct urb *urb)
71{
72 struct usb_mixer_interface *mixer = urb->context;
73 const struct rc_config *rc = mixer->rc_cfg;
74 u32 code;
75
76 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
77 return;
78
79 code = mixer->rc_buffer[rc->offset];
80 if (rc->length == 2)
81 code |= mixer->rc_buffer[rc->offset + 1] << 8;
82
83 /* the Mute button actually changes the mixer control */
84 if (code == rc->mute_code)
85 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
86 mixer->rc_code = code;
87 wmb();
88 wake_up(&mixer->rc_waitq);
89}
90
91static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
92 long count, loff_t *offset)
93{
94 struct usb_mixer_interface *mixer = hw->private_data;
95 int err;
96 u32 rc_code;
97
98 if (count != 1 && count != 4)
99 return -EINVAL;
100 err = wait_event_interruptible(mixer->rc_waitq,
101 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
102 if (err == 0) {
103 if (count == 1)
104 err = put_user(rc_code, buf);
105 else
106 err = put_user(rc_code, (u32 __user *)buf);
107 }
108 return err < 0 ? err : count;
109}
110
111static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
112 poll_table *wait)
113{
114 struct usb_mixer_interface *mixer = hw->private_data;
115
116 poll_wait(file, &mixer->rc_waitq, wait);
117 return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
118}
119
120static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
121{
122 struct snd_hwdep *hwdep;
123 int err, len, i;
124
125 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
126 if (rc_configs[i].usb_id == mixer->chip->usb_id)
127 break;
128 if (i >= ARRAY_SIZE(rc_configs))
129 return 0;
130 mixer->rc_cfg = &rc_configs[i];
131
132 len = mixer->rc_cfg->packet_length;
133
134 init_waitqueue_head(&mixer->rc_waitq);
135 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
136 if (err < 0)
137 return err;
138 snprintf(hwdep->name, sizeof(hwdep->name),
139 "%s remote control", mixer->chip->card->shortname);
140 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
141 hwdep->private_data = mixer;
142 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
143 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
144 hwdep->exclusive = 1;
145
146 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
147 if (!mixer->rc_urb)
148 return -ENOMEM;
149 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
150 if (!mixer->rc_setup_packet) {
151 usb_free_urb(mixer->rc_urb);
152 mixer->rc_urb = NULL;
153 return -ENOMEM;
154 }
155 mixer->rc_setup_packet->bRequestType =
156 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
157 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
158 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
159 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
160 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
161 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
162 usb_rcvctrlpipe(mixer->chip->dev, 0),
163 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
164 snd_usb_soundblaster_remote_complete, mixer);
165 return 0;
166}
167
168#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
169
170static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
171{
172 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
173 int index = kcontrol->private_value;
174
175 ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
176 return 0;
177}
178
179static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
180{
181 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
182 int index = kcontrol->private_value;
183 int value = ucontrol->value.integer.value[0];
184 int err, changed;
185
186 if (value > 1)
187 return -EINVAL;
188 changed = value != mixer->audigy2nx_leds[index];
189 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3042))
190 err = snd_usb_ctl_msg(mixer->chip->dev,
191 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
192 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
193 !value, 0, NULL, 0, 100);
194 /* USB X-Fi S51 Pro */
195 if (mixer->chip->usb_id == USB_ID(0x041e, 0x30df))
196 err = snd_usb_ctl_msg(mixer->chip->dev,
197 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
198 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
199 !value, 0, NULL, 0, 100);
200 else
201 err = snd_usb_ctl_msg(mixer->chip->dev,
202 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
203 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
204 value, index + 2, NULL, 0, 100);
205 if (err < 0)
206 return err;
207 mixer->audigy2nx_leds[index] = value;
208 return changed;
209}
210
211static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
212 {
213 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
214 .name = "CMSS LED Switch",
215 .info = snd_audigy2nx_led_info,
216 .get = snd_audigy2nx_led_get,
217 .put = snd_audigy2nx_led_put,
218 .private_value = 0,
219 },
220 {
221 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
222 .name = "Power LED Switch",
223 .info = snd_audigy2nx_led_info,
224 .get = snd_audigy2nx_led_get,
225 .put = snd_audigy2nx_led_put,
226 .private_value = 1,
227 },
228 {
229 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
230 .name = "Dolby Digital LED Switch",
231 .info = snd_audigy2nx_led_info,
232 .get = snd_audigy2nx_led_get,
233 .put = snd_audigy2nx_led_put,
234 .private_value = 2,
235 },
236};
237
238static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
239{
240 int i, err;
241
242 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
243 /* USB X-Fi S51 doesn't have a CMSS LED */
244 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
245 continue;
246 /* USB X-Fi S51 Pro doesn't have one either */
247 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
248 continue;
249 if (i > 1 && /* Live24ext has 2 LEDs only */
250 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
251 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
252 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
253 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
254 break;
255 err = snd_ctl_add(mixer->chip->card,
256 snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
257 if (err < 0)
258 return err;
259 }
260 mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
261 return 0;
262}
263
264static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
265 struct snd_info_buffer *buffer)
266{
267 static const struct sb_jack {
268 int unitid;
269 const char *name;
270 } jacks_audigy2nx[] = {
271 {4, "dig in "},
272 {7, "line in"},
273 {19, "spk out"},
274 {20, "hph out"},
275 {-1, NULL}
276 }, jacks_live24ext[] = {
277 {4, "line in"}, /* &1=Line, &2=Mic*/
278 {3, "hph out"}, /* headphones */
279 {0, "RC "}, /* last command, 6 bytes see rc_config above */
280 {-1, NULL}
281 };
282 const struct sb_jack *jacks;
283 struct usb_mixer_interface *mixer = entry->private_data;
284 int i, err;
285 u8 buf[3];
286
287 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
288 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
289 jacks = jacks_audigy2nx;
290 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
291 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
292 jacks = jacks_live24ext;
293 else
294 return;
295
296 for (i = 0; jacks[i].name; ++i) {
297 snd_iprintf(buffer, "%s: ", jacks[i].name);
298 err = snd_usb_ctl_msg(mixer->chip->dev,
299 usb_rcvctrlpipe(mixer->chip->dev, 0),
300 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
301 USB_RECIP_INTERFACE, 0,
302 jacks[i].unitid << 8, buf, 3, 100);
303 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
304 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
305 else
306 snd_iprintf(buffer, "?\n");
307 }
308}
309
310static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
311 struct snd_ctl_elem_value *ucontrol)
312{
313 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
314
315 ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
316 return 0;
317}
318
319static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
320 struct snd_ctl_elem_value *ucontrol)
321{
322 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
323 u8 old_status, new_status;
324 int err, changed;
325
326 old_status = mixer->xonar_u1_status;
327 if (ucontrol->value.integer.value[0])
328 new_status = old_status | 0x02;
329 else
330 new_status = old_status & ~0x02;
331 changed = new_status != old_status;
332 err = snd_usb_ctl_msg(mixer->chip->dev,
333 usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
334 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
335 50, 0, &new_status, 1, 100);
336 if (err < 0)
337 return err;
338 mixer->xonar_u1_status = new_status;
339 return changed;
340}
341
342static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
343 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
344 .name = "Digital Playback Switch",
345 .info = snd_ctl_boolean_mono_info,
346 .get = snd_xonar_u1_switch_get,
347 .put = snd_xonar_u1_switch_put,
348};
349
350static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
351{
352 int err;
353
354 err = snd_ctl_add(mixer->chip->card,
355 snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
356 if (err < 0)
357 return err;
358 mixer->xonar_u1_status = 0x05;
359 return 0;
360}
361
362/* Native Instruments device quirks */
363
364#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
365
366static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
367 struct snd_ctl_elem_value *ucontrol)
368{
369 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
370 struct usb_device *dev = mixer->chip->dev;
371 u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
372 u16 wIndex = kcontrol->private_value & 0xffff;
373 u8 tmp;
374
375 int ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
376 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
377 0, cpu_to_le16(wIndex),
378 &tmp, sizeof(tmp), 1000);
379
380 if (ret < 0) {
381 snd_printk(KERN_ERR
382 "unable to issue vendor read request (ret = %d)", ret);
383 return ret;
384 }
385
386 ucontrol->value.integer.value[0] = tmp;
387
388 return 0;
389}
390
391static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
392 struct snd_ctl_elem_value *ucontrol)
393{
394 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
395 struct usb_device *dev = mixer->chip->dev;
396 u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
397 u16 wIndex = kcontrol->private_value & 0xffff;
398 u16 wValue = ucontrol->value.integer.value[0];
399
400 int ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), bRequest,
401 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
402 cpu_to_le16(wValue), cpu_to_le16(wIndex),
403 NULL, 0, 1000);
404
405 if (ret < 0) {
406 snd_printk(KERN_ERR
407 "unable to issue vendor write request (ret = %d)", ret);
408 return ret;
409 }
410
411 return 0;
412}
413
414static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
415 {
416 .name = "Direct Thru Channel A",
417 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
418 },
419 {
420 .name = "Direct Thru Channel B",
421 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
422 },
423 {
424 .name = "Phono Input Channel A",
425 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
426 },
427 {
428 .name = "Phono Input Channel B",
429 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
430 },
431};
432
433static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
434 {
435 .name = "Direct Thru Channel A",
436 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
437 },
438 {
439 .name = "Direct Thru Channel B",
440 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
441 },
442 {
443 .name = "Direct Thru Channel C",
444 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
445 },
446 {
447 .name = "Direct Thru Channel D",
448 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
449 },
450 {
451 .name = "Phono Input Channel A",
452 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
453 },
454 {
455 .name = "Phono Input Channel B",
456 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
457 },
458 {
459 .name = "Phono Input Channel C",
460 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
461 },
462 {
463 .name = "Phono Input Channel D",
464 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
465 },
466};
467
468static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
469 const struct snd_kcontrol_new *kc,
470 unsigned int count)
471{
472 int i, err = 0;
473 struct snd_kcontrol_new template = {
474 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
475 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
476 .get = snd_nativeinstruments_control_get,
477 .put = snd_nativeinstruments_control_put,
478 .info = snd_ctl_boolean_mono_info,
479 };
480
481 for (i = 0; i < count; i++) {
482 struct snd_kcontrol *c;
483
484 template.name = kc[i].name;
485 template.private_value = kc[i].private_value;
486
487 c = snd_ctl_new1(&template, mixer);
488 err = snd_ctl_add(mixer->chip->card, c);
489
490 if (err < 0)
491 break;
492 }
493
494 return err;
495}
496
497/* M-Audio FastTrack Ultra quirks */
498
499/* private_free callback */
500static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
501{
502 kfree(kctl->private_data);
503 kctl->private_data = NULL;
504}
505
506static int snd_maudio_ftu_create_ctl(struct usb_mixer_interface *mixer,
507 int in, int out, const char *name)
508{
509 struct usb_mixer_elem_info *cval;
510 struct snd_kcontrol *kctl;
511
512 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
513 if (!cval)
514 return -ENOMEM;
515
516 cval->id = 5;
517 cval->mixer = mixer;
518 cval->val_type = USB_MIXER_S16;
519 cval->channels = 1;
520 cval->control = out + 1;
521 cval->cmask = 1 << in;
522
523 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
524 if (!kctl) {
525 kfree(cval);
526 return -ENOMEM;
527 }
528
529 snprintf(kctl->id.name, sizeof(kctl->id.name), name);
530 kctl->private_free = usb_mixer_elem_free;
531 return snd_usb_mixer_add_control(mixer, kctl);
532}
533
534static int snd_maudio_ftu_create_mixer(struct usb_mixer_interface *mixer)
535{
536 char name[64];
537 int in, out, err;
538
539 for (out = 0; out < 8; out++) {
540 for (in = 0; in < 8; in++) {
541 snprintf(name, sizeof(name),
542 "AIn%d - Out%d Capture Volume", in + 1, out + 1);
543 err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
544 if (err < 0)
545 return err;
546 }
547
548 for (in = 8; in < 16; in++) {
549 snprintf(name, sizeof(name),
550 "DIn%d - Out%d Playback Volume", in - 7, out + 1);
551 err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
552 if (err < 0)
553 return err;
554 }
555 }
556
557 return 0;
558}
559
560void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
561 unsigned char samplerate_id)
562{
563 struct usb_mixer_interface *mixer;
564 struct usb_mixer_elem_info *cval;
565 int unitid = 12; /* SamleRate ExtensionUnit ID */
566
567 list_for_each_entry(mixer, &chip->mixer_list, list) {
568 cval = mixer->id_elems[unitid];
569 if (cval) {
570 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
571 cval->control << 8,
572 samplerate_id);
573 snd_usb_mixer_notify_id(mixer, unitid);
574 }
575 break;
576 }
577}
578
579int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
580{
581 int err = 0;
582 struct snd_info_entry *entry;
583
584 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
585 return err;
586
587 switch (mixer->chip->usb_id) {
588 case USB_ID(0x041e, 0x3020):
589 case USB_ID(0x041e, 0x3040):
590 case USB_ID(0x041e, 0x3042):
591 case USB_ID(0x041e, 0x30df):
592 case USB_ID(0x041e, 0x3048):
593 err = snd_audigy2nx_controls_create(mixer);
594 if (err < 0)
595 break;
596 if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
597 snd_info_set_text_ops(entry, mixer,
598 snd_audigy2nx_proc_read);
599 break;
600
601 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
602 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
603 err = snd_maudio_ftu_create_mixer(mixer);
604 break;
605
606 case USB_ID(0x0b05, 0x1739):
607 case USB_ID(0x0b05, 0x1743):
608 err = snd_xonar_u1_controls_create(mixer);
609 break;
610
611 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
612 err = snd_nativeinstruments_create_mixer(mixer,
613 snd_nativeinstruments_ta6_mixers,
614 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
615 break;
616
617 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
618 err = snd_nativeinstruments_create_mixer(mixer,
619 snd_nativeinstruments_ta10_mixers,
620 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
621 break;
622 }
623
624 return err;
625}
626
627void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
628 int unitid)
629{
630 if (!mixer->rc_cfg)
631 return;
632 /* unit ids specific to Extigy/Audigy 2 NX: */
633 switch (unitid) {
634 case 0: /* remote control */
635 mixer->rc_urb->dev = mixer->chip->dev;
636 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
637 break;
638 case 4: /* digital in jack */
639 case 7: /* line in jacks */
640 case 19: /* speaker out jacks */
641 case 20: /* headphones out jack */
642 break;
643 /* live24ext: 4 = line-in jack */
644 case 3: /* hp-out jack (may actuate Mute) */
645 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
646 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
647 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
648 break;
649 default:
650 snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
651 break;
652 }
653}
654
1/*
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 *
12 * Audio Advantage Micro II support added by:
13 * Przemek Rudy (prudy1@o2.pl)
14 *
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>
31#include <linux/slab.h>
32#include <linux/usb.h>
33#include <linux/usb/audio.h>
34
35#include <sound/asoundef.h>
36#include <sound/core.h>
37#include <sound/control.h>
38#include <sound/hwdep.h>
39#include <sound/info.h>
40#include <sound/tlv.h>
41
42#include "usbaudio.h"
43#include "mixer.h"
44#include "mixer_quirks.h"
45#include "mixer_scarlett.h"
46#include "helper.h"
47
48extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;
49
50struct std_mono_table {
51 unsigned int unitid, control, cmask;
52 int val_type;
53 const char *name;
54 snd_kcontrol_tlv_rw_t *tlv_callback;
55};
56
57/* This function allows for the creation of standard UAC controls.
58 * See the quirks for M-Audio FTUs or Ebox-44.
59 * If you don't want to set a TLV callback pass NULL.
60 *
61 * Since there doesn't seem to be a devices that needs a multichannel
62 * version, we keep it mono for simplicity.
63 */
64static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
65 unsigned int unitid,
66 unsigned int control,
67 unsigned int cmask,
68 int val_type,
69 unsigned int idx_off,
70 const char *name,
71 snd_kcontrol_tlv_rw_t *tlv_callback)
72{
73 struct usb_mixer_elem_info *cval;
74 struct snd_kcontrol *kctl;
75
76 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
77 if (!cval)
78 return -ENOMEM;
79
80 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
81 cval->val_type = val_type;
82 cval->channels = 1;
83 cval->control = control;
84 cval->cmask = cmask;
85 cval->idx_off = idx_off;
86
87 /* get_min_max() is called only for integer volumes later,
88 * so provide a short-cut for booleans */
89 cval->min = 0;
90 cval->max = 1;
91 cval->res = 0;
92 cval->dBmin = 0;
93 cval->dBmax = 0;
94
95 /* Create control */
96 kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
97 if (!kctl) {
98 kfree(cval);
99 return -ENOMEM;
100 }
101
102 /* Set name */
103 snprintf(kctl->id.name, sizeof(kctl->id.name), name);
104 kctl->private_free = snd_usb_mixer_elem_free;
105
106 /* set TLV */
107 if (tlv_callback) {
108 kctl->tlv.c = tlv_callback;
109 kctl->vd[0].access |=
110 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
111 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
112 }
113 /* Add control to mixer */
114 return snd_usb_mixer_add_control(&cval->head, kctl);
115}
116
117static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
118 unsigned int unitid,
119 unsigned int control,
120 unsigned int cmask,
121 int val_type,
122 const char *name,
123 snd_kcontrol_tlv_rw_t *tlv_callback)
124{
125 return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
126 val_type, 0 /* Offset */, name, tlv_callback);
127}
128
129/*
130 * Create a set of standard UAC controls from a table
131 */
132static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
133 struct std_mono_table *t)
134{
135 int err;
136
137 while (t->name != NULL) {
138 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
139 t->cmask, t->val_type, t->name, t->tlv_callback);
140 if (err < 0)
141 return err;
142 t++;
143 }
144
145 return 0;
146}
147
148static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer,
149 int id,
150 usb_mixer_elem_resume_func_t resume,
151 const struct snd_kcontrol_new *knew,
152 struct usb_mixer_elem_list **listp)
153{
154 struct usb_mixer_elem_list *list;
155 struct snd_kcontrol *kctl;
156
157 list = kzalloc(sizeof(*list), GFP_KERNEL);
158 if (!list)
159 return -ENOMEM;
160 if (listp)
161 *listp = list;
162 list->mixer = mixer;
163 list->id = id;
164 list->resume = resume;
165 kctl = snd_ctl_new1(knew, list);
166 if (!kctl) {
167 kfree(list);
168 return -ENOMEM;
169 }
170 kctl->private_free = snd_usb_mixer_elem_free;
171 return snd_usb_mixer_add_control(list, kctl);
172}
173
174/*
175 * Sound Blaster remote control configuration
176 *
177 * format of remote control data:
178 * Extigy: xx 00
179 * Audigy 2 NX: 06 80 xx 00 00 00
180 * Live! 24-bit: 06 80 xx yy 22 83
181 */
182static const struct rc_config {
183 u32 usb_id;
184 u8 offset;
185 u8 length;
186 u8 packet_length;
187 u8 min_packet_length; /* minimum accepted length of the URB result */
188 u8 mute_mixer_id;
189 u32 mute_code;
190} rc_configs[] = {
191 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
192 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
193 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
194 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
195 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
196 { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
197 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
198};
199
200static void snd_usb_soundblaster_remote_complete(struct urb *urb)
201{
202 struct usb_mixer_interface *mixer = urb->context;
203 const struct rc_config *rc = mixer->rc_cfg;
204 u32 code;
205
206 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
207 return;
208
209 code = mixer->rc_buffer[rc->offset];
210 if (rc->length == 2)
211 code |= mixer->rc_buffer[rc->offset + 1] << 8;
212
213 /* the Mute button actually changes the mixer control */
214 if (code == rc->mute_code)
215 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
216 mixer->rc_code = code;
217 wmb();
218 wake_up(&mixer->rc_waitq);
219}
220
221static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
222 long count, loff_t *offset)
223{
224 struct usb_mixer_interface *mixer = hw->private_data;
225 int err;
226 u32 rc_code;
227
228 if (count != 1 && count != 4)
229 return -EINVAL;
230 err = wait_event_interruptible(mixer->rc_waitq,
231 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
232 if (err == 0) {
233 if (count == 1)
234 err = put_user(rc_code, buf);
235 else
236 err = put_user(rc_code, (u32 __user *)buf);
237 }
238 return err < 0 ? err : count;
239}
240
241static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
242 poll_table *wait)
243{
244 struct usb_mixer_interface *mixer = hw->private_data;
245
246 poll_wait(file, &mixer->rc_waitq, wait);
247 return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
248}
249
250static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
251{
252 struct snd_hwdep *hwdep;
253 int err, len, i;
254
255 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
256 if (rc_configs[i].usb_id == mixer->chip->usb_id)
257 break;
258 if (i >= ARRAY_SIZE(rc_configs))
259 return 0;
260 mixer->rc_cfg = &rc_configs[i];
261
262 len = mixer->rc_cfg->packet_length;
263
264 init_waitqueue_head(&mixer->rc_waitq);
265 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
266 if (err < 0)
267 return err;
268 snprintf(hwdep->name, sizeof(hwdep->name),
269 "%s remote control", mixer->chip->card->shortname);
270 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
271 hwdep->private_data = mixer;
272 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
273 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
274 hwdep->exclusive = 1;
275
276 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
277 if (!mixer->rc_urb)
278 return -ENOMEM;
279 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
280 if (!mixer->rc_setup_packet) {
281 usb_free_urb(mixer->rc_urb);
282 mixer->rc_urb = NULL;
283 return -ENOMEM;
284 }
285 mixer->rc_setup_packet->bRequestType =
286 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
287 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
288 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
289 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
290 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
291 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
292 usb_rcvctrlpipe(mixer->chip->dev, 0),
293 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
294 snd_usb_soundblaster_remote_complete, mixer);
295 return 0;
296}
297
298#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
299
300static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
301{
302 ucontrol->value.integer.value[0] = kcontrol->private_value >> 8;
303 return 0;
304}
305
306static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer,
307 int value, int index)
308{
309 struct snd_usb_audio *chip = mixer->chip;
310 int err;
311
312 err = snd_usb_lock_shutdown(chip);
313 if (err < 0)
314 return err;
315
316 if (chip->usb_id == USB_ID(0x041e, 0x3042))
317 err = snd_usb_ctl_msg(chip->dev,
318 usb_sndctrlpipe(chip->dev, 0), 0x24,
319 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
320 !value, 0, NULL, 0);
321 /* USB X-Fi S51 Pro */
322 if (chip->usb_id == USB_ID(0x041e, 0x30df))
323 err = snd_usb_ctl_msg(chip->dev,
324 usb_sndctrlpipe(chip->dev, 0), 0x24,
325 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
326 !value, 0, NULL, 0);
327 else
328 err = snd_usb_ctl_msg(chip->dev,
329 usb_sndctrlpipe(chip->dev, 0), 0x24,
330 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
331 value, index + 2, NULL, 0);
332 snd_usb_unlock_shutdown(chip);
333 return err;
334}
335
336static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol,
337 struct snd_ctl_elem_value *ucontrol)
338{
339 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
340 struct usb_mixer_interface *mixer = list->mixer;
341 int index = kcontrol->private_value & 0xff;
342 unsigned int value = ucontrol->value.integer.value[0];
343 int old_value = kcontrol->private_value >> 8;
344 int err;
345
346 if (value > 1)
347 return -EINVAL;
348 if (value == old_value)
349 return 0;
350 kcontrol->private_value = (value << 8) | index;
351 err = snd_audigy2nx_led_update(mixer, value, index);
352 return err < 0 ? err : 1;
353}
354
355static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list)
356{
357 int priv_value = list->kctl->private_value;
358
359 return snd_audigy2nx_led_update(list->mixer, priv_value >> 8,
360 priv_value & 0xff);
361}
362
363/* name and private_value are set dynamically */
364static struct snd_kcontrol_new snd_audigy2nx_control = {
365 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
366 .info = snd_audigy2nx_led_info,
367 .get = snd_audigy2nx_led_get,
368 .put = snd_audigy2nx_led_put,
369};
370
371static const char * const snd_audigy2nx_led_names[] = {
372 "CMSS LED Switch",
373 "Power LED Switch",
374 "Dolby Digital LED Switch",
375};
376
377static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
378{
379 int i, err;
380
381 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) {
382 struct snd_kcontrol_new knew;
383
384 /* USB X-Fi S51 doesn't have a CMSS LED */
385 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
386 continue;
387 /* USB X-Fi S51 Pro doesn't have one either */
388 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
389 continue;
390 if (i > 1 && /* Live24ext has 2 LEDs only */
391 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
392 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
393 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
394 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
395 break;
396
397 knew = snd_audigy2nx_control;
398 knew.name = snd_audigy2nx_led_names[i];
399 knew.private_value = (1 << 8) | i; /* LED on as default */
400 err = add_single_ctl_with_resume(mixer, 0,
401 snd_audigy2nx_led_resume,
402 &knew, NULL);
403 if (err < 0)
404 return err;
405 }
406 return 0;
407}
408
409static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
410 struct snd_info_buffer *buffer)
411{
412 static const struct sb_jack {
413 int unitid;
414 const char *name;
415 } jacks_audigy2nx[] = {
416 {4, "dig in "},
417 {7, "line in"},
418 {19, "spk out"},
419 {20, "hph out"},
420 {-1, NULL}
421 }, jacks_live24ext[] = {
422 {4, "line in"}, /* &1=Line, &2=Mic*/
423 {3, "hph out"}, /* headphones */
424 {0, "RC "}, /* last command, 6 bytes see rc_config above */
425 {-1, NULL}
426 };
427 const struct sb_jack *jacks;
428 struct usb_mixer_interface *mixer = entry->private_data;
429 int i, err;
430 u8 buf[3];
431
432 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
433 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
434 jacks = jacks_audigy2nx;
435 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
436 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
437 jacks = jacks_live24ext;
438 else
439 return;
440
441 for (i = 0; jacks[i].name; ++i) {
442 snd_iprintf(buffer, "%s: ", jacks[i].name);
443 err = snd_usb_lock_shutdown(mixer->chip);
444 if (err < 0)
445 return;
446 err = snd_usb_ctl_msg(mixer->chip->dev,
447 usb_rcvctrlpipe(mixer->chip->dev, 0),
448 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
449 USB_RECIP_INTERFACE, 0,
450 jacks[i].unitid << 8, buf, 3);
451 snd_usb_unlock_shutdown(mixer->chip);
452 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
453 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
454 else
455 snd_iprintf(buffer, "?\n");
456 }
457}
458
459/* EMU0204 */
460static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
461 struct snd_ctl_elem_info *uinfo)
462{
463 static const char * const texts[2] = {"1/2", "3/4"};
464
465 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
466}
467
468static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
469 struct snd_ctl_elem_value *ucontrol)
470{
471 ucontrol->value.enumerated.item[0] = kcontrol->private_value;
472 return 0;
473}
474
475static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer,
476 int value)
477{
478 struct snd_usb_audio *chip = mixer->chip;
479 int err;
480 unsigned char buf[2];
481
482 err = snd_usb_lock_shutdown(chip);
483 if (err < 0)
484 return err;
485
486 buf[0] = 0x01;
487 buf[1] = value ? 0x02 : 0x01;
488 err = snd_usb_ctl_msg(chip->dev,
489 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
490 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
491 0x0400, 0x0e00, buf, 2);
492 snd_usb_unlock_shutdown(chip);
493 return err;
494}
495
496static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
497 struct snd_ctl_elem_value *ucontrol)
498{
499 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
500 struct usb_mixer_interface *mixer = list->mixer;
501 unsigned int value = ucontrol->value.enumerated.item[0];
502 int err;
503
504 if (value > 1)
505 return -EINVAL;
506
507 if (value == kcontrol->private_value)
508 return 0;
509
510 kcontrol->private_value = value;
511 err = snd_emu0204_ch_switch_update(mixer, value);
512 return err < 0 ? err : 1;
513}
514
515static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list)
516{
517 return snd_emu0204_ch_switch_update(list->mixer,
518 list->kctl->private_value);
519}
520
521static struct snd_kcontrol_new snd_emu0204_control = {
522 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
523 .name = "Front Jack Channels",
524 .info = snd_emu0204_ch_switch_info,
525 .get = snd_emu0204_ch_switch_get,
526 .put = snd_emu0204_ch_switch_put,
527 .private_value = 0,
528};
529
530static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
531{
532 return add_single_ctl_with_resume(mixer, 0,
533 snd_emu0204_ch_switch_resume,
534 &snd_emu0204_control, NULL);
535}
536
537/* ASUS Xonar U1 / U3 controls */
538
539static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
540 struct snd_ctl_elem_value *ucontrol)
541{
542 ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02);
543 return 0;
544}
545
546static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer,
547 unsigned char status)
548{
549 struct snd_usb_audio *chip = mixer->chip;
550 int err;
551
552 err = snd_usb_lock_shutdown(chip);
553 if (err < 0)
554 return err;
555 err = snd_usb_ctl_msg(chip->dev,
556 usb_sndctrlpipe(chip->dev, 0), 0x08,
557 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
558 50, 0, &status, 1);
559 snd_usb_unlock_shutdown(chip);
560 return err;
561}
562
563static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
564 struct snd_ctl_elem_value *ucontrol)
565{
566 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
567 u8 old_status, new_status;
568 int err;
569
570 old_status = kcontrol->private_value;
571 if (ucontrol->value.integer.value[0])
572 new_status = old_status | 0x02;
573 else
574 new_status = old_status & ~0x02;
575 if (new_status == old_status)
576 return 0;
577
578 kcontrol->private_value = new_status;
579 err = snd_xonar_u1_switch_update(list->mixer, new_status);
580 return err < 0 ? err : 1;
581}
582
583static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list)
584{
585 return snd_xonar_u1_switch_update(list->mixer,
586 list->kctl->private_value);
587}
588
589static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
590 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
591 .name = "Digital Playback Switch",
592 .info = snd_ctl_boolean_mono_info,
593 .get = snd_xonar_u1_switch_get,
594 .put = snd_xonar_u1_switch_put,
595 .private_value = 0x05,
596};
597
598static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
599{
600 return add_single_ctl_with_resume(mixer, 0,
601 snd_xonar_u1_switch_resume,
602 &snd_xonar_u1_output_switch, NULL);
603}
604
605/* Digidesign Mbox 1 clock source switch (internal/spdif) */
606
607static int snd_mbox1_switch_get(struct snd_kcontrol *kctl,
608 struct snd_ctl_elem_value *ucontrol)
609{
610 ucontrol->value.enumerated.item[0] = kctl->private_value;
611 return 0;
612}
613
614static int snd_mbox1_switch_update(struct usb_mixer_interface *mixer, int val)
615{
616 struct snd_usb_audio *chip = mixer->chip;
617 int err;
618 unsigned char buff[3];
619
620 err = snd_usb_lock_shutdown(chip);
621 if (err < 0)
622 return err;
623
624 /* Prepare for magic command to toggle clock source */
625 err = snd_usb_ctl_msg(chip->dev,
626 usb_rcvctrlpipe(chip->dev, 0), 0x81,
627 USB_DIR_IN |
628 USB_TYPE_CLASS |
629 USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1);
630 if (err < 0)
631 goto err;
632 err = snd_usb_ctl_msg(chip->dev,
633 usb_rcvctrlpipe(chip->dev, 0), 0x81,
634 USB_DIR_IN |
635 USB_TYPE_CLASS |
636 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
637 if (err < 0)
638 goto err;
639
640 /* 2 possibilities: Internal -> send sample rate
641 * S/PDIF sync -> send zeroes
642 * NB: Sample rate locked to 48kHz on purpose to
643 * prevent user from resetting the sample rate
644 * while S/PDIF sync is enabled and confusing
645 * this configuration.
646 */
647 if (val == 0) {
648 buff[0] = 0x80;
649 buff[1] = 0xbb;
650 buff[2] = 0x00;
651 } else {
652 buff[0] = buff[1] = buff[2] = 0x00;
653 }
654
655 /* Send the magic command to toggle the clock source */
656 err = snd_usb_ctl_msg(chip->dev,
657 usb_sndctrlpipe(chip->dev, 0), 0x1,
658 USB_TYPE_CLASS |
659 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
660 if (err < 0)
661 goto err;
662 err = snd_usb_ctl_msg(chip->dev,
663 usb_rcvctrlpipe(chip->dev, 0), 0x81,
664 USB_DIR_IN |
665 USB_TYPE_CLASS |
666 USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
667 if (err < 0)
668 goto err;
669 err = snd_usb_ctl_msg(chip->dev,
670 usb_rcvctrlpipe(chip->dev, 0), 0x81,
671 USB_DIR_IN |
672 USB_TYPE_CLASS |
673 USB_RECIP_ENDPOINT, 0x100, 0x2, buff, 3);
674 if (err < 0)
675 goto err;
676
677err:
678 snd_usb_unlock_shutdown(chip);
679 return err;
680}
681
682static int snd_mbox1_switch_put(struct snd_kcontrol *kctl,
683 struct snd_ctl_elem_value *ucontrol)
684{
685 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
686 struct usb_mixer_interface *mixer = list->mixer;
687 int err;
688 bool cur_val, new_val;
689
690 cur_val = kctl->private_value;
691 new_val = ucontrol->value.enumerated.item[0];
692 if (cur_val == new_val)
693 return 0;
694
695 kctl->private_value = new_val;
696 err = snd_mbox1_switch_update(mixer, new_val);
697 return err < 0 ? err : 1;
698}
699
700static int snd_mbox1_switch_info(struct snd_kcontrol *kcontrol,
701 struct snd_ctl_elem_info *uinfo)
702{
703 static const char *const texts[2] = {
704 "Internal",
705 "S/PDIF"
706 };
707
708 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
709}
710
711static int snd_mbox1_switch_resume(struct usb_mixer_elem_list *list)
712{
713 return snd_mbox1_switch_update(list->mixer, list->kctl->private_value);
714}
715
716static struct snd_kcontrol_new snd_mbox1_switch = {
717 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
718 .name = "Clock Source",
719 .index = 0,
720 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
721 .info = snd_mbox1_switch_info,
722 .get = snd_mbox1_switch_get,
723 .put = snd_mbox1_switch_put,
724 .private_value = 0
725};
726
727static int snd_mbox1_create_sync_switch(struct usb_mixer_interface *mixer)
728{
729 return add_single_ctl_with_resume(mixer, 0,
730 snd_mbox1_switch_resume,
731 &snd_mbox1_switch, NULL);
732}
733
734/* Native Instruments device quirks */
735
736#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
737
738static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
739 struct snd_kcontrol *kctl)
740{
741 struct usb_device *dev = mixer->chip->dev;
742 unsigned int pval = kctl->private_value;
743 u8 value;
744 int err;
745
746 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
747 (pval >> 16) & 0xff,
748 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
749 0, pval & 0xffff, &value, 1);
750 if (err < 0) {
751 dev_err(&dev->dev,
752 "unable to issue vendor read request (ret = %d)", err);
753 return err;
754 }
755
756 kctl->private_value |= (value << 24);
757 return 0;
758}
759
760static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
761 struct snd_ctl_elem_value *ucontrol)
762{
763 ucontrol->value.integer.value[0] = kcontrol->private_value >> 24;
764 return 0;
765}
766
767static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list)
768{
769 struct snd_usb_audio *chip = list->mixer->chip;
770 unsigned int pval = list->kctl->private_value;
771 int err;
772
773 err = snd_usb_lock_shutdown(chip);
774 if (err < 0)
775 return err;
776 err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
777 (pval >> 16) & 0xff,
778 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
779 pval >> 24, pval & 0xffff, NULL, 0, 1000);
780 snd_usb_unlock_shutdown(chip);
781 return err;
782}
783
784static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
785 struct snd_ctl_elem_value *ucontrol)
786{
787 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
788 u8 oldval = (kcontrol->private_value >> 24) & 0xff;
789 u8 newval = ucontrol->value.integer.value[0];
790 int err;
791
792 if (oldval == newval)
793 return 0;
794
795 kcontrol->private_value &= ~(0xff << 24);
796 kcontrol->private_value |= (unsigned int)newval << 24;
797 err = snd_ni_update_cur_val(list);
798 return err < 0 ? err : 1;
799}
800
801static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
802 {
803 .name = "Direct Thru Channel A",
804 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
805 },
806 {
807 .name = "Direct Thru Channel B",
808 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
809 },
810 {
811 .name = "Phono Input Channel A",
812 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
813 },
814 {
815 .name = "Phono Input Channel B",
816 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
817 },
818};
819
820static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
821 {
822 .name = "Direct Thru Channel A",
823 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
824 },
825 {
826 .name = "Direct Thru Channel B",
827 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
828 },
829 {
830 .name = "Direct Thru Channel C",
831 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
832 },
833 {
834 .name = "Direct Thru Channel D",
835 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
836 },
837 {
838 .name = "Phono Input Channel A",
839 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
840 },
841 {
842 .name = "Phono Input Channel B",
843 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
844 },
845 {
846 .name = "Phono Input Channel C",
847 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
848 },
849 {
850 .name = "Phono Input Channel D",
851 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
852 },
853};
854
855static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
856 const struct snd_kcontrol_new *kc,
857 unsigned int count)
858{
859 int i, err = 0;
860 struct snd_kcontrol_new template = {
861 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
862 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
863 .get = snd_nativeinstruments_control_get,
864 .put = snd_nativeinstruments_control_put,
865 .info = snd_ctl_boolean_mono_info,
866 };
867
868 for (i = 0; i < count; i++) {
869 struct usb_mixer_elem_list *list;
870
871 template.name = kc[i].name;
872 template.private_value = kc[i].private_value;
873
874 err = add_single_ctl_with_resume(mixer, 0,
875 snd_ni_update_cur_val,
876 &template, &list);
877 if (err < 0)
878 break;
879 snd_ni_control_init_val(mixer, list->kctl);
880 }
881
882 return err;
883}
884
885/* M-Audio FastTrack Ultra quirks */
886/* FTU Effect switch (also used by C400/C600) */
887static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
888 struct snd_ctl_elem_info *uinfo)
889{
890 static const char *const texts[8] = {
891 "Room 1", "Room 2", "Room 3", "Hall 1",
892 "Hall 2", "Plate", "Delay", "Echo"
893 };
894
895 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
896}
897
898static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
899 struct snd_kcontrol *kctl)
900{
901 struct usb_device *dev = mixer->chip->dev;
902 unsigned int pval = kctl->private_value;
903 int err;
904 unsigned char value[2];
905
906 value[0] = 0x00;
907 value[1] = 0x00;
908
909 err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
910 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
911 pval & 0xff00,
912 snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8),
913 value, 2);
914 if (err < 0)
915 return err;
916
917 kctl->private_value |= value[0] << 24;
918 return 0;
919}
920
921static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
922 struct snd_ctl_elem_value *ucontrol)
923{
924 ucontrol->value.enumerated.item[0] = kctl->private_value >> 24;
925 return 0;
926}
927
928static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list)
929{
930 struct snd_usb_audio *chip = list->mixer->chip;
931 unsigned int pval = list->kctl->private_value;
932 unsigned char value[2];
933 int err;
934
935 value[0] = pval >> 24;
936 value[1] = 0;
937
938 err = snd_usb_lock_shutdown(chip);
939 if (err < 0)
940 return err;
941 err = snd_usb_ctl_msg(chip->dev,
942 usb_sndctrlpipe(chip->dev, 0),
943 UAC_SET_CUR,
944 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
945 pval & 0xff00,
946 snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8),
947 value, 2);
948 snd_usb_unlock_shutdown(chip);
949 return err;
950}
951
952static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
953 struct snd_ctl_elem_value *ucontrol)
954{
955 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
956 unsigned int pval = list->kctl->private_value;
957 int cur_val, err, new_val;
958
959 cur_val = pval >> 24;
960 new_val = ucontrol->value.enumerated.item[0];
961 if (cur_val == new_val)
962 return 0;
963
964 kctl->private_value &= ~(0xff << 24);
965 kctl->private_value |= new_val << 24;
966 err = snd_ftu_eff_switch_update(list);
967 return err < 0 ? err : 1;
968}
969
970static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
971 int validx, int bUnitID)
972{
973 static struct snd_kcontrol_new template = {
974 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
975 .name = "Effect Program Switch",
976 .index = 0,
977 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
978 .info = snd_ftu_eff_switch_info,
979 .get = snd_ftu_eff_switch_get,
980 .put = snd_ftu_eff_switch_put
981 };
982 struct usb_mixer_elem_list *list;
983 int err;
984
985 err = add_single_ctl_with_resume(mixer, bUnitID,
986 snd_ftu_eff_switch_update,
987 &template, &list);
988 if (err < 0)
989 return err;
990 list->kctl->private_value = (validx << 8) | bUnitID;
991 snd_ftu_eff_switch_init(mixer, list->kctl);
992 return 0;
993}
994
995/* Create volume controls for FTU devices*/
996static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
997{
998 char name[64];
999 unsigned int control, cmask;
1000 int in, out, err;
1001
1002 const unsigned int id = 5;
1003 const int val_type = USB_MIXER_S16;
1004
1005 for (out = 0; out < 8; out++) {
1006 control = out + 1;
1007 for (in = 0; in < 8; in++) {
1008 cmask = 1 << in;
1009 snprintf(name, sizeof(name),
1010 "AIn%d - Out%d Capture Volume",
1011 in + 1, out + 1);
1012 err = snd_create_std_mono_ctl(mixer, id, control,
1013 cmask, val_type, name,
1014 &snd_usb_mixer_vol_tlv);
1015 if (err < 0)
1016 return err;
1017 }
1018 for (in = 8; in < 16; in++) {
1019 cmask = 1 << in;
1020 snprintf(name, sizeof(name),
1021 "DIn%d - Out%d Playback Volume",
1022 in - 7, out + 1);
1023 err = snd_create_std_mono_ctl(mixer, id, control,
1024 cmask, val_type, name,
1025 &snd_usb_mixer_vol_tlv);
1026 if (err < 0)
1027 return err;
1028 }
1029 }
1030
1031 return 0;
1032}
1033
1034/* This control needs a volume quirk, see mixer.c */
1035static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1036{
1037 static const char name[] = "Effect Volume";
1038 const unsigned int id = 6;
1039 const int val_type = USB_MIXER_U8;
1040 const unsigned int control = 2;
1041 const unsigned int cmask = 0;
1042
1043 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1044 name, snd_usb_mixer_vol_tlv);
1045}
1046
1047/* This control needs a volume quirk, see mixer.c */
1048static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1049{
1050 static const char name[] = "Effect Duration";
1051 const unsigned int id = 6;
1052 const int val_type = USB_MIXER_S16;
1053 const unsigned int control = 3;
1054 const unsigned int cmask = 0;
1055
1056 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1057 name, snd_usb_mixer_vol_tlv);
1058}
1059
1060/* This control needs a volume quirk, see mixer.c */
1061static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1062{
1063 static const char name[] = "Effect Feedback Volume";
1064 const unsigned int id = 6;
1065 const int val_type = USB_MIXER_U8;
1066 const unsigned int control = 4;
1067 const unsigned int cmask = 0;
1068
1069 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1070 name, NULL);
1071}
1072
1073static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1074{
1075 unsigned int cmask;
1076 int err, ch;
1077 char name[48];
1078
1079 const unsigned int id = 7;
1080 const int val_type = USB_MIXER_S16;
1081 const unsigned int control = 7;
1082
1083 for (ch = 0; ch < 4; ++ch) {
1084 cmask = 1 << ch;
1085 snprintf(name, sizeof(name),
1086 "Effect Return %d Volume", ch + 1);
1087 err = snd_create_std_mono_ctl(mixer, id, control,
1088 cmask, val_type, name,
1089 snd_usb_mixer_vol_tlv);
1090 if (err < 0)
1091 return err;
1092 }
1093
1094 return 0;
1095}
1096
1097static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1098{
1099 unsigned int cmask;
1100 int err, ch;
1101 char name[48];
1102
1103 const unsigned int id = 5;
1104 const int val_type = USB_MIXER_S16;
1105 const unsigned int control = 9;
1106
1107 for (ch = 0; ch < 8; ++ch) {
1108 cmask = 1 << ch;
1109 snprintf(name, sizeof(name),
1110 "Effect Send AIn%d Volume", ch + 1);
1111 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1112 val_type, name,
1113 snd_usb_mixer_vol_tlv);
1114 if (err < 0)
1115 return err;
1116 }
1117 for (ch = 8; ch < 16; ++ch) {
1118 cmask = 1 << ch;
1119 snprintf(name, sizeof(name),
1120 "Effect Send DIn%d Volume", ch - 7);
1121 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1122 val_type, name,
1123 snd_usb_mixer_vol_tlv);
1124 if (err < 0)
1125 return err;
1126 }
1127 return 0;
1128}
1129
1130static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1131{
1132 int err;
1133
1134 err = snd_ftu_create_volume_ctls(mixer);
1135 if (err < 0)
1136 return err;
1137
1138 err = snd_ftu_create_effect_switch(mixer, 1, 6);
1139 if (err < 0)
1140 return err;
1141
1142 err = snd_ftu_create_effect_volume_ctl(mixer);
1143 if (err < 0)
1144 return err;
1145
1146 err = snd_ftu_create_effect_duration_ctl(mixer);
1147 if (err < 0)
1148 return err;
1149
1150 err = snd_ftu_create_effect_feedback_ctl(mixer);
1151 if (err < 0)
1152 return err;
1153
1154 err = snd_ftu_create_effect_return_ctls(mixer);
1155 if (err < 0)
1156 return err;
1157
1158 err = snd_ftu_create_effect_send_ctls(mixer);
1159 if (err < 0)
1160 return err;
1161
1162 return 0;
1163}
1164
1165void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1166 unsigned char samplerate_id)
1167{
1168 struct usb_mixer_interface *mixer;
1169 struct usb_mixer_elem_info *cval;
1170 int unitid = 12; /* SamleRate ExtensionUnit ID */
1171
1172 list_for_each_entry(mixer, &chip->mixer_list, list) {
1173 cval = (struct usb_mixer_elem_info *)mixer->id_elems[unitid];
1174 if (cval) {
1175 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1176 cval->control << 8,
1177 samplerate_id);
1178 snd_usb_mixer_notify_id(mixer, unitid);
1179 }
1180 break;
1181 }
1182}
1183
1184/* M-Audio Fast Track C400/C600 */
1185/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1186static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1187{
1188 char name[64];
1189 unsigned int cmask, offset;
1190 int out, chan, err;
1191 int num_outs = 0;
1192 int num_ins = 0;
1193
1194 const unsigned int id = 0x40;
1195 const int val_type = USB_MIXER_S16;
1196 const int control = 1;
1197
1198 switch (mixer->chip->usb_id) {
1199 case USB_ID(0x0763, 0x2030):
1200 num_outs = 6;
1201 num_ins = 4;
1202 break;
1203 case USB_ID(0x0763, 0x2031):
1204 num_outs = 8;
1205 num_ins = 6;
1206 break;
1207 }
1208
1209 for (chan = 0; chan < num_outs + num_ins; chan++) {
1210 for (out = 0; out < num_outs; out++) {
1211 if (chan < num_outs) {
1212 snprintf(name, sizeof(name),
1213 "PCM%d-Out%d Playback Volume",
1214 chan + 1, out + 1);
1215 } else {
1216 snprintf(name, sizeof(name),
1217 "In%d-Out%d Playback Volume",
1218 chan - num_outs + 1, out + 1);
1219 }
1220
1221 cmask = (out == 0) ? 0 : 1 << (out - 1);
1222 offset = chan * num_outs;
1223 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1224 cmask, val_type, offset, name,
1225 &snd_usb_mixer_vol_tlv);
1226 if (err < 0)
1227 return err;
1228 }
1229 }
1230
1231 return 0;
1232}
1233
1234/* This control needs a volume quirk, see mixer.c */
1235static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1236{
1237 static const char name[] = "Effect Volume";
1238 const unsigned int id = 0x43;
1239 const int val_type = USB_MIXER_U8;
1240 const unsigned int control = 3;
1241 const unsigned int cmask = 0;
1242
1243 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1244 name, snd_usb_mixer_vol_tlv);
1245}
1246
1247/* This control needs a volume quirk, see mixer.c */
1248static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1249{
1250 static const char name[] = "Effect Duration";
1251 const unsigned int id = 0x43;
1252 const int val_type = USB_MIXER_S16;
1253 const unsigned int control = 4;
1254 const unsigned int cmask = 0;
1255
1256 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1257 name, snd_usb_mixer_vol_tlv);
1258}
1259
1260/* This control needs a volume quirk, see mixer.c */
1261static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1262{
1263 static const char name[] = "Effect Feedback Volume";
1264 const unsigned int id = 0x43;
1265 const int val_type = USB_MIXER_U8;
1266 const unsigned int control = 5;
1267 const unsigned int cmask = 0;
1268
1269 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1270 name, NULL);
1271}
1272
1273static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1274{
1275 char name[64];
1276 unsigned int cmask;
1277 int chan, err;
1278 int num_outs = 0;
1279 int num_ins = 0;
1280
1281 const unsigned int id = 0x42;
1282 const int val_type = USB_MIXER_S16;
1283 const int control = 1;
1284
1285 switch (mixer->chip->usb_id) {
1286 case USB_ID(0x0763, 0x2030):
1287 num_outs = 6;
1288 num_ins = 4;
1289 break;
1290 case USB_ID(0x0763, 0x2031):
1291 num_outs = 8;
1292 num_ins = 6;
1293 break;
1294 }
1295
1296 for (chan = 0; chan < num_outs + num_ins; chan++) {
1297 if (chan < num_outs) {
1298 snprintf(name, sizeof(name),
1299 "Effect Send DOut%d",
1300 chan + 1);
1301 } else {
1302 snprintf(name, sizeof(name),
1303 "Effect Send AIn%d",
1304 chan - num_outs + 1);
1305 }
1306
1307 cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1308 err = snd_create_std_mono_ctl(mixer, id, control,
1309 cmask, val_type, name,
1310 &snd_usb_mixer_vol_tlv);
1311 if (err < 0)
1312 return err;
1313 }
1314
1315 return 0;
1316}
1317
1318static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1319{
1320 char name[64];
1321 unsigned int cmask;
1322 int chan, err;
1323 int num_outs = 0;
1324 int offset = 0;
1325
1326 const unsigned int id = 0x40;
1327 const int val_type = USB_MIXER_S16;
1328 const int control = 1;
1329
1330 switch (mixer->chip->usb_id) {
1331 case USB_ID(0x0763, 0x2030):
1332 num_outs = 6;
1333 offset = 0x3c;
1334 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1335 break;
1336 case USB_ID(0x0763, 0x2031):
1337 num_outs = 8;
1338 offset = 0x70;
1339 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1340 break;
1341 }
1342
1343 for (chan = 0; chan < num_outs; chan++) {
1344 snprintf(name, sizeof(name),
1345 "Effect Return %d",
1346 chan + 1);
1347
1348 cmask = (chan == 0) ? 0 :
1349 1 << (chan + (chan % 2) * num_outs - 1);
1350 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1351 cmask, val_type, offset, name,
1352 &snd_usb_mixer_vol_tlv);
1353 if (err < 0)
1354 return err;
1355 }
1356
1357 return 0;
1358}
1359
1360static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1361{
1362 int err;
1363
1364 err = snd_c400_create_vol_ctls(mixer);
1365 if (err < 0)
1366 return err;
1367
1368 err = snd_c400_create_effect_vol_ctls(mixer);
1369 if (err < 0)
1370 return err;
1371
1372 err = snd_c400_create_effect_ret_vol_ctls(mixer);
1373 if (err < 0)
1374 return err;
1375
1376 err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1377 if (err < 0)
1378 return err;
1379
1380 err = snd_c400_create_effect_volume_ctl(mixer);
1381 if (err < 0)
1382 return err;
1383
1384 err = snd_c400_create_effect_duration_ctl(mixer);
1385 if (err < 0)
1386 return err;
1387
1388 err = snd_c400_create_effect_feedback_ctl(mixer);
1389 if (err < 0)
1390 return err;
1391
1392 return 0;
1393}
1394
1395/*
1396 * The mixer units for Ebox-44 are corrupt, and even where they
1397 * are valid they presents mono controls as L and R channels of
1398 * stereo. So we provide a good mixer here.
1399 */
1400static struct std_mono_table ebox44_table[] = {
1401 {
1402 .unitid = 4,
1403 .control = 1,
1404 .cmask = 0x0,
1405 .val_type = USB_MIXER_INV_BOOLEAN,
1406 .name = "Headphone Playback Switch"
1407 },
1408 {
1409 .unitid = 4,
1410 .control = 2,
1411 .cmask = 0x1,
1412 .val_type = USB_MIXER_S16,
1413 .name = "Headphone A Mix Playback Volume"
1414 },
1415 {
1416 .unitid = 4,
1417 .control = 2,
1418 .cmask = 0x2,
1419 .val_type = USB_MIXER_S16,
1420 .name = "Headphone B Mix Playback Volume"
1421 },
1422
1423 {
1424 .unitid = 7,
1425 .control = 1,
1426 .cmask = 0x0,
1427 .val_type = USB_MIXER_INV_BOOLEAN,
1428 .name = "Output Playback Switch"
1429 },
1430 {
1431 .unitid = 7,
1432 .control = 2,
1433 .cmask = 0x1,
1434 .val_type = USB_MIXER_S16,
1435 .name = "Output A Playback Volume"
1436 },
1437 {
1438 .unitid = 7,
1439 .control = 2,
1440 .cmask = 0x2,
1441 .val_type = USB_MIXER_S16,
1442 .name = "Output B Playback Volume"
1443 },
1444
1445 {
1446 .unitid = 10,
1447 .control = 1,
1448 .cmask = 0x0,
1449 .val_type = USB_MIXER_INV_BOOLEAN,
1450 .name = "Input Capture Switch"
1451 },
1452 {
1453 .unitid = 10,
1454 .control = 2,
1455 .cmask = 0x1,
1456 .val_type = USB_MIXER_S16,
1457 .name = "Input A Capture Volume"
1458 },
1459 {
1460 .unitid = 10,
1461 .control = 2,
1462 .cmask = 0x2,
1463 .val_type = USB_MIXER_S16,
1464 .name = "Input B Capture Volume"
1465 },
1466
1467 {}
1468};
1469
1470/* Audio Advantage Micro II findings:
1471 *
1472 * Mapping spdif AES bits to vendor register.bit:
1473 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1474 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1475 * AES2: [0 0 0 0 0 0 0 0]
1476 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1477 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1478 *
1479 * power on values:
1480 * r2: 0x10
1481 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1482 * just after it to 0xa0, presumably it disables/mutes some analog
1483 * parts when there is no audio.)
1484 * r9: 0x28
1485 *
1486 * Optical transmitter on/off:
1487 * vendor register.bit: 9.1
1488 * 0 - on (0x28 register value)
1489 * 1 - off (0x2a register value)
1490 *
1491 */
1492static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1493 struct snd_ctl_elem_info *uinfo)
1494{
1495 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1496 uinfo->count = 1;
1497 return 0;
1498}
1499
1500static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1501 struct snd_ctl_elem_value *ucontrol)
1502{
1503 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1504 struct snd_usb_audio *chip = list->mixer->chip;
1505 int err;
1506 struct usb_interface *iface;
1507 struct usb_host_interface *alts;
1508 unsigned int ep;
1509 unsigned char data[3];
1510 int rate;
1511
1512 err = snd_usb_lock_shutdown(chip);
1513 if (err < 0)
1514 return err;
1515
1516 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1517 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1518 ucontrol->value.iec958.status[2] = 0x00;
1519
1520 /* use known values for that card: interface#1 altsetting#1 */
1521 iface = usb_ifnum_to_if(chip->dev, 1);
1522 if (!iface || iface->num_altsetting < 2)
1523 return -EINVAL;
1524 alts = &iface->altsetting[1];
1525 if (get_iface_desc(alts)->bNumEndpoints < 1)
1526 return -EINVAL;
1527 ep = get_endpoint(alts, 0)->bEndpointAddress;
1528
1529 err = snd_usb_ctl_msg(chip->dev,
1530 usb_rcvctrlpipe(chip->dev, 0),
1531 UAC_GET_CUR,
1532 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1533 UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1534 ep,
1535 data,
1536 sizeof(data));
1537 if (err < 0)
1538 goto end;
1539
1540 rate = data[0] | (data[1] << 8) | (data[2] << 16);
1541 ucontrol->value.iec958.status[3] = (rate == 48000) ?
1542 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1543
1544 err = 0;
1545 end:
1546 snd_usb_unlock_shutdown(chip);
1547 return err;
1548}
1549
1550static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list)
1551{
1552 struct snd_usb_audio *chip = list->mixer->chip;
1553 unsigned int pval = list->kctl->private_value;
1554 u8 reg;
1555 int err;
1556
1557 err = snd_usb_lock_shutdown(chip);
1558 if (err < 0)
1559 return err;
1560
1561 reg = ((pval >> 4) & 0xf0) | (pval & 0x0f);
1562 err = snd_usb_ctl_msg(chip->dev,
1563 usb_sndctrlpipe(chip->dev, 0),
1564 UAC_SET_CUR,
1565 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1566 reg,
1567 2,
1568 NULL,
1569 0);
1570 if (err < 0)
1571 goto end;
1572
1573 reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20;
1574 reg |= (pval >> 12) & 0x0f;
1575 err = snd_usb_ctl_msg(chip->dev,
1576 usb_sndctrlpipe(chip->dev, 0),
1577 UAC_SET_CUR,
1578 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1579 reg,
1580 3,
1581 NULL,
1582 0);
1583 if (err < 0)
1584 goto end;
1585
1586 end:
1587 snd_usb_unlock_shutdown(chip);
1588 return err;
1589}
1590
1591static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1592 struct snd_ctl_elem_value *ucontrol)
1593{
1594 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1595 unsigned int pval, pval_old;
1596 int err;
1597
1598 pval = pval_old = kcontrol->private_value;
1599 pval &= 0xfffff0f0;
1600 pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1601 pval |= (ucontrol->value.iec958.status[0] & 0x0f);
1602
1603 pval &= 0xffff0fff;
1604 pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1605
1606 /* The frequency bits in AES3 cannot be set via register access. */
1607
1608 /* Silently ignore any bits from the request that cannot be set. */
1609
1610 if (pval == pval_old)
1611 return 0;
1612
1613 kcontrol->private_value = pval;
1614 err = snd_microii_spdif_default_update(list);
1615 return err < 0 ? err : 1;
1616}
1617
1618static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1619 struct snd_ctl_elem_value *ucontrol)
1620{
1621 ucontrol->value.iec958.status[0] = 0x0f;
1622 ucontrol->value.iec958.status[1] = 0xff;
1623 ucontrol->value.iec958.status[2] = 0x00;
1624 ucontrol->value.iec958.status[3] = 0x00;
1625
1626 return 0;
1627}
1628
1629static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1630 struct snd_ctl_elem_value *ucontrol)
1631{
1632 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1633
1634 return 0;
1635}
1636
1637static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list)
1638{
1639 struct snd_usb_audio *chip = list->mixer->chip;
1640 u8 reg = list->kctl->private_value;
1641 int err;
1642
1643 err = snd_usb_lock_shutdown(chip);
1644 if (err < 0)
1645 return err;
1646
1647 err = snd_usb_ctl_msg(chip->dev,
1648 usb_sndctrlpipe(chip->dev, 0),
1649 UAC_SET_CUR,
1650 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1651 reg,
1652 9,
1653 NULL,
1654 0);
1655
1656 snd_usb_unlock_shutdown(chip);
1657 return err;
1658}
1659
1660static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1661 struct snd_ctl_elem_value *ucontrol)
1662{
1663 struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1664 u8 reg;
1665 int err;
1666
1667 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1668 if (reg != list->kctl->private_value)
1669 return 0;
1670
1671 kcontrol->private_value = reg;
1672 err = snd_microii_spdif_switch_update(list);
1673 return err < 0 ? err : 1;
1674}
1675
1676static struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1677 {
1678 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1679 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1680 .info = snd_microii_spdif_info,
1681 .get = snd_microii_spdif_default_get,
1682 .put = snd_microii_spdif_default_put,
1683 .private_value = 0x00000100UL,/* reset value */
1684 },
1685 {
1686 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1687 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1688 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1689 .info = snd_microii_spdif_info,
1690 .get = snd_microii_spdif_mask_get,
1691 },
1692 {
1693 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1694 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1695 .info = snd_ctl_boolean_mono_info,
1696 .get = snd_microii_spdif_switch_get,
1697 .put = snd_microii_spdif_switch_put,
1698 .private_value = 0x00000028UL,/* reset value */
1699 }
1700};
1701
1702static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1703{
1704 int err, i;
1705 static usb_mixer_elem_resume_func_t resume_funcs[] = {
1706 snd_microii_spdif_default_update,
1707 NULL,
1708 snd_microii_spdif_switch_update
1709 };
1710
1711 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1712 err = add_single_ctl_with_resume(mixer, 0,
1713 resume_funcs[i],
1714 &snd_microii_mixer_spdif[i],
1715 NULL);
1716 if (err < 0)
1717 return err;
1718 }
1719
1720 return 0;
1721}
1722
1723int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
1724{
1725 int err = 0;
1726 struct snd_info_entry *entry;
1727
1728 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
1729 return err;
1730
1731 switch (mixer->chip->usb_id) {
1732 case USB_ID(0x041e, 0x3020):
1733 case USB_ID(0x041e, 0x3040):
1734 case USB_ID(0x041e, 0x3042):
1735 case USB_ID(0x041e, 0x30df):
1736 case USB_ID(0x041e, 0x3048):
1737 err = snd_audigy2nx_controls_create(mixer);
1738 if (err < 0)
1739 break;
1740 if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
1741 snd_info_set_text_ops(entry, mixer,
1742 snd_audigy2nx_proc_read);
1743 break;
1744
1745 /* EMU0204 */
1746 case USB_ID(0x041e, 0x3f19):
1747 err = snd_emu0204_controls_create(mixer);
1748 if (err < 0)
1749 break;
1750 break;
1751
1752 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
1753 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
1754 err = snd_c400_create_mixer(mixer);
1755 break;
1756
1757 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
1758 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
1759 err = snd_ftu_create_mixer(mixer);
1760 break;
1761
1762 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
1763 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
1764 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
1765 err = snd_xonar_u1_controls_create(mixer);
1766 break;
1767
1768 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
1769 err = snd_microii_controls_create(mixer);
1770 break;
1771
1772 case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */
1773 err = snd_mbox1_create_sync_switch(mixer);
1774 break;
1775
1776 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
1777 err = snd_nativeinstruments_create_mixer(mixer,
1778 snd_nativeinstruments_ta6_mixers,
1779 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
1780 break;
1781
1782 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
1783 err = snd_nativeinstruments_create_mixer(mixer,
1784 snd_nativeinstruments_ta10_mixers,
1785 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
1786 break;
1787
1788 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
1789 /* detection is disabled in mixer_maps.c */
1790 err = snd_create_std_mono_table(mixer, ebox44_table);
1791 break;
1792
1793 case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */
1794 case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */
1795 case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */
1796 case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */
1797 case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */
1798 err = snd_scarlett_controls_create(mixer);
1799 break;
1800 }
1801
1802 return err;
1803}
1804
1805void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
1806 int unitid)
1807{
1808 if (!mixer->rc_cfg)
1809 return;
1810 /* unit ids specific to Extigy/Audigy 2 NX: */
1811 switch (unitid) {
1812 case 0: /* remote control */
1813 mixer->rc_urb->dev = mixer->chip->dev;
1814 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
1815 break;
1816 case 4: /* digital in jack */
1817 case 7: /* line in jacks */
1818 case 19: /* speaker out jacks */
1819 case 20: /* headphones out jack */
1820 break;
1821 /* live24ext: 4 = line-in jack */
1822 case 3: /* hp-out jack (may actuate Mute) */
1823 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
1824 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
1825 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
1826 break;
1827 default:
1828 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
1829 break;
1830 }
1831}
1832
1833static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
1834 struct usb_mixer_elem_info *cval,
1835 struct snd_kcontrol *kctl)
1836{
1837 /* Approximation using 10 ranges based on output measurement on hw v1.2.
1838 * This seems close to the cubic mapping e.g. alsamixer uses. */
1839 static const DECLARE_TLV_DB_RANGE(scale,
1840 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970),
1841 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160),
1842 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710),
1843 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560),
1844 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324),
1845 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031),
1846 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393),
1847 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032),
1848 32, 40, TLV_DB_MINMAX_ITEM(-968, -490),
1849 41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
1850 );
1851
1852 if (cval->min == 0 && cval->max == 50) {
1853 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
1854 kctl->tlv.p = scale;
1855 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1856 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1857
1858 } else if (cval->min == 0 && cval->max <= 1000) {
1859 /* Some other clearly broken DragonFly variant.
1860 * At least a 0..53 variant (hw v1.0) exists.
1861 */
1862 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
1863 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1864 }
1865}
1866
1867void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
1868 struct usb_mixer_elem_info *cval, int unitid,
1869 struct snd_kcontrol *kctl)
1870{
1871 switch (mixer->chip->usb_id) {
1872 case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
1873 if (unitid == 7 && cval->control == UAC_FU_VOLUME)
1874 snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
1875 break;
1876 }
1877}
1878