projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: Fix invalid kerneldoc markers
[deliverable/linux.git] / sound / usb / mixer_quirks.c
CommitLineData
7b1eda22
DM		 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 *
066624c6
PR		 12 * Audio Advantage Micro II support added by:
13 * Przemek Rudy (prudy1@o2.pl)
7b1eda22
DM		 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>
36db0456 31#include <linux/slab.h>
7b1eda22
DM		 32#include <linux/usb.h>
33#include <linux/usb/audio.h>
34
066624c6 35#include <sound/asoundef.h>
7b1eda22
DM		 36#include <sound/core.h>
37#include <sound/control.h>
38#include <sound/hwdep.h>
39#include <sound/info.h>
40
41#include "usbaudio.h"
f0b5e634 42#include "mixer.h"
7b1eda22
DM		 43#include "mixer_quirks.h"
44#include "helper.h"
45
d5a0bf6c
DM		 46extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;
47
b71dad18
MH		 48struct 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
8a4d1d39
FH		 55/* 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 */
9f814105 69static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
8a4d1d39
FH		 70 unsigned int unitid,
71 unsigned int control,
72 unsigned int cmask,
73 int val_type,
9f814105 74 unsigned int idx_off,
8a4d1d39
FH		 75 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;
9f814105 92 cval->idx_off = idx_off;
8a4d1d39 93
7df4a691
MH		 94 /* get_min_max() is called only for integer volumes later,
95 * so provide a short-cut for booleans */
8a4d1d39
FH		 96 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
9f814105
EZ		 128static 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
b71dad18
MH		 140/*
141 * 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
7b1eda22
DM		 159/*
160 * 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 */
ca8dc34e 179 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
7cdd8d73 180 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
7b1eda22
DM		 181 { 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];
888ea7d5
TI		 303 down_read(&mixer->chip->shutdown_rwsem);
304 if (mixer->chip->shutdown) {
305 err = -ENODEV;
306 goto out;
307 }
ca8dc34e
MJ		 308 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,
17d900c4 312 !value, 0, NULL, 0);
7cdd8d73
MB		 313 /* 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,
17d900c4 318 !value, 0, NULL, 0);
ca8dc34e
MJ		 319 else
320 err = snd_usb_ctl_msg(mixer->chip->dev,
7b1eda22
DM		 321 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
322 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
17d900c4 323 value, index + 2, NULL, 0);
888ea7d5
TI		 324 out:
325 up_read(&mixer->chip->shutdown_rwsem);
7b1eda22
DM		 326 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) {
ca8dc34e
MJ		 364 /* USB X-Fi S51 doesn't have a CMSS LED */
365 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
366 continue;
7cdd8d73
MB		 367 /* USB X-Fi S51 Pro doesn't have one either */
368 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
369 continue;
7b1eda22
DM		 370 if (i > 1 && /* Live24ext has 2 LEDs only */
371 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
ca8dc34e 372 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
7cdd8d73 373 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
7b1eda22
DM		 374 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);
888ea7d5
TI		 419 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,
7b1eda22
DM		 424 usb_rcvctrlpipe(mixer->chip->dev, 0),
425 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
426 USB_RECIP_INTERFACE, 0,
17d900c4 427 jacks[i].unitid << 8, buf, 3);
888ea7d5 428 up_read(&mixer->chip->shutdown_rwsem);
7b1eda22
DM		 429 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
44832a71
VK		 436/* EMU0204 */
437static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
438 struct snd_ctl_elem_info *uinfo)
439{
7bbd03e0 440 static const char * const texts[2] = {"1/2", "3/4"};
44832a71 441
7bbd03e0 442 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
44832a71
VK		 443}
444
445static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
446 struct snd_ctl_elem_value *ucontrol)
447{
448 ucontrol->value.enumerated.item[0] = kcontrol->private_value;
449 return 0;
450}
451
452static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
453 struct snd_ctl_elem_value *ucontrol)
454{
455 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
456 unsigned int value = ucontrol->value.enumerated.item[0];
457 int err, changed;
458 unsigned char buf[2];
459
460 if (value > 1)
461 return -EINVAL;
462
463 buf[0] = 0x01;
464 buf[1] = value ? 0x02 : 0x01;
465
466 changed = value != kcontrol->private_value;
467 down_read(&mixer->chip->shutdown_rwsem);
468 if (mixer->chip->shutdown) {
469 err = -ENODEV;
470 goto out;
471 }
472 err = snd_usb_ctl_msg(mixer->chip->dev,
473 usb_sndctrlpipe(mixer->chip->dev, 0), UAC_SET_CUR,
474 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
475 0x0400, 0x0e00, buf, 2);
476 out:
477 up_read(&mixer->chip->shutdown_rwsem);
478 if (err < 0)
479 return err;
480 kcontrol->private_value = value;
481 return changed;
482}
483
484
485static struct snd_kcontrol_new snd_emu0204_controls[] = {
486 {
487 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
488 .name = "Front Jack Channels",
489 .info = snd_emu0204_ch_switch_info,
490 .get = snd_emu0204_ch_switch_get,
491 .put = snd_emu0204_ch_switch_put,
492 .private_value = 0,
493 },
494};
495
496static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
497{
498 int i, err;
499
500 for (i = 0; i < ARRAY_SIZE(snd_emu0204_controls); ++i) {
501 err = snd_ctl_add(mixer->chip->card,
502 snd_ctl_new1(&snd_emu0204_controls[i], mixer));
503 if (err < 0)
504 return err;
505 }
506
507 return 0;
508}
1d31affb
DW		 509/* ASUS Xonar U1 / U3 controls */
510
7b1eda22
DM		 511static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
512 struct snd_ctl_elem_value *ucontrol)
513{
514 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
515
516 ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
517 return 0;
518}
519
520static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
521 struct snd_ctl_elem_value *ucontrol)
522{
523 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
524 u8 old_status, new_status;
525 int err, changed;
526
527 old_status = mixer->xonar_u1_status;
528 if (ucontrol->value.integer.value[0])
529 new_status = old_status | 0x02;
530 else
531 new_status = old_status & ~0x02;
532 changed = new_status != old_status;
888ea7d5
TI		 533 down_read(&mixer->chip->shutdown_rwsem);
534 if (mixer->chip->shutdown)
535 err = -ENODEV;
536 else
537 err = snd_usb_ctl_msg(mixer->chip->dev,
7b1eda22
DM		 538 usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
539 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
17d900c4 540 50, 0, &new_status, 1);
888ea7d5 541 up_read(&mixer->chip->shutdown_rwsem);
7b1eda22
DM		 542 if (err < 0)
543 return err;
544 mixer->xonar_u1_status = new_status;
545 return changed;
546}
547
548static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
549 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
550 .name = "Digital Playback Switch",
551 .info = snd_ctl_boolean_mono_info,
552 .get = snd_xonar_u1_switch_get,
553 .put = snd_xonar_u1_switch_put,
554};
555
556static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
557{
558 int err;
559
560 err = snd_ctl_add(mixer->chip->card,
561 snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
562 if (err < 0)
563 return err;
564 mixer->xonar_u1_status = 0x05;
565 return 0;
566}
567
54a8c500
DM		 568/* Native Instruments device quirks */
569
570#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
571
572static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
573 struct snd_ctl_elem_value *ucontrol)
574{
575 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
576 struct usb_device *dev = mixer->chip->dev;
577 u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
578 u16 wIndex = kcontrol->private_value & 0xffff;
579 u8 tmp;
888ea7d5 580 int ret;
54a8c500 581
888ea7d5
TI		 582 down_read(&mixer->chip->shutdown_rwsem);
583 if (mixer->chip->shutdown)
584 ret = -ENODEV;
585 else
586 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
54a8c500 587 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
889d6684 588 0, wIndex,
54a8c500 589 &tmp, sizeof(tmp), 1000);
888ea7d5 590 up_read(&mixer->chip->shutdown_rwsem);
54a8c500
DM		 591
592 if (ret < 0) {
0ba41d91
TI		 593 dev_err(&dev->dev,
594 "unable to issue vendor read request (ret = %d)", ret);
54a8c500
DM		 595 return ret;
596 }
597
598 ucontrol->value.integer.value[0] = tmp;
599
600 return 0;
601}
602
603static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
604 struct snd_ctl_elem_value *ucontrol)
605{
606 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
607 struct usb_device *dev = mixer->chip->dev;
608 u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
609 u16 wIndex = kcontrol->private_value & 0xffff;
610 u16 wValue = ucontrol->value.integer.value[0];
888ea7d5 611 int ret;
54a8c500 612
888ea7d5
TI		 613 down_read(&mixer->chip->shutdown_rwsem);
614 if (mixer->chip->shutdown)
615 ret = -ENODEV;
616 else
617 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), bRequest,
54a8c500 618 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
889d6684 619 wValue, wIndex,
54a8c500 620 NULL, 0, 1000);
888ea7d5 621 up_read(&mixer->chip->shutdown_rwsem);
54a8c500
DM		 622
623 if (ret < 0) {
0ba41d91
TI		 624 dev_err(&dev->dev,
625 "unable to issue vendor write request (ret = %d)", ret);
54a8c500
DM		 626 return ret;
627 }
628
629 return 0;
630}
631
632static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
633 {
634 .name = "Direct Thru Channel A",
635 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
636 },
637 {
638 .name = "Direct Thru Channel B",
639 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
640 },
641 {
642 .name = "Phono Input Channel A",
643 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
644 },
645 {
646 .name = "Phono Input Channel B",
647 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
648 },
649};
650
651static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
652 {
653 .name = "Direct Thru Channel A",
654 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
655 },
656 {
657 .name = "Direct Thru Channel B",
658 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
659 },
660 {
661 .name = "Direct Thru Channel C",
662 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
663 },
664 {
665 .name = "Direct Thru Channel D",
666 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
667 },
668 {
669 .name = "Phono Input Channel A",
670 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
671 },
672 {
673 .name = "Phono Input Channel B",
674 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
675 },
676 {
677 .name = "Phono Input Channel C",
678 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
679 },
680 {
681 .name = "Phono Input Channel D",
682 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
683 },
684};
685
686static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
687 const struct snd_kcontrol_new *kc,
688 unsigned int count)
689{
690 int i, err = 0;
691 struct snd_kcontrol_new template = {
692 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
693 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
694 .get = snd_nativeinstruments_control_get,
695 .put = snd_nativeinstruments_control_put,
696 .info = snd_ctl_boolean_mono_info,
697 };
698
699 for (i = 0; i < count; i++) {
700 struct snd_kcontrol *c;
701
702 template.name = kc[i].name;
703 template.private_value = kc[i].private_value;
704
705 c = snd_ctl_new1(&template, mixer);
706 err = snd_ctl_add(mixer->chip->card, c);
707
708 if (err < 0)
709 break;
710 }
711
712 return err;
713}
714
d5a0bf6c 715/* M-Audio FastTrack Ultra quirks */
e9a25e04 716/* FTU Effect switch (also used by C400/C600) */
d34bf148
FH		 717struct snd_ftu_eff_switch_priv_val {
718 struct usb_mixer_interface *mixer;
719 int cached_value;
720 int is_cached;
d847ce0e
EZ		 721 int bUnitID;
722 int validx;
d34bf148
FH		 723};
724
725static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
726 struct snd_ctl_elem_info *uinfo)
727{
7bbd03e0
TI		 728 static const char *const texts[8] = {
729 "Room 1", "Room 2", "Room 3", "Hall 1",
730 "Hall 2", "Plate", "Delay", "Echo"
d34bf148
FH		 731 };
732
7bbd03e0 733 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
d34bf148
FH		 734}
735
736static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
737 struct snd_ctl_elem_value *ucontrol)
738{
739 struct snd_usb_audio *chip;
740 struct usb_mixer_interface *mixer;
741 struct snd_ftu_eff_switch_priv_val *pval;
742 int err;
743 unsigned char value[2];
d847ce0e 744 int id, validx;
d34bf148 745
d34bf148
FH		 746 const int val_len = 2;
747
748 value[0] = 0x00;
749 value[1] = 0x00;
750
751 pval = (struct snd_ftu_eff_switch_priv_val *)
752 kctl->private_value;
753
754 if (pval->is_cached) {
755 ucontrol->value.enumerated.item[0] = pval->cached_value;
756 return 0;
757 }
758
759 mixer = (struct usb_mixer_interface *) pval->mixer;
760 if (snd_BUG_ON(!mixer))
761 return -EINVAL;
762
763 chip = (struct snd_usb_audio *) mixer->chip;
764 if (snd_BUG_ON(!chip))
765 return -EINVAL;
766
d847ce0e
EZ		 767 id = pval->bUnitID;
768 validx = pval->validx;
d34bf148 769
888ea7d5
TI		 770 down_read(&mixer->chip->shutdown_rwsem);
771 if (mixer->chip->shutdown)
772 err = -ENODEV;
773 else
774 err = snd_usb_ctl_msg(chip->dev,
d34bf148
FH		 775 usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
776 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
777 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
778 value, val_len);
888ea7d5 779 up_read(&mixer->chip->shutdown_rwsem);
d34bf148
FH		 780 if (err < 0)
781 return err;
782
783 ucontrol->value.enumerated.item[0] = value[0];
784 pval->cached_value = value[0];
785 pval->is_cached = 1;
786
787 return 0;
788}
789
790static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
791 struct snd_ctl_elem_value *ucontrol)
792{
793 struct snd_usb_audio *chip;
794 struct snd_ftu_eff_switch_priv_val *pval;
795
796 struct usb_mixer_interface *mixer;
797 int changed, cur_val, err, new_val;
798 unsigned char value[2];
d847ce0e 799 int id, validx;
d34bf148 800
d34bf148
FH		 801 const int val_len = 2;
802
803 changed = 0;
804
805 pval = (struct snd_ftu_eff_switch_priv_val *)
806 kctl->private_value;
807 cur_val = pval->cached_value;
808 new_val = ucontrol->value.enumerated.item[0];
809
810 mixer = (struct usb_mixer_interface *) pval->mixer;
811 if (snd_BUG_ON(!mixer))
812 return -EINVAL;
813
814 chip = (struct snd_usb_audio *) mixer->chip;
815 if (snd_BUG_ON(!chip))
816 return -EINVAL;
817
d847ce0e
EZ		 818 id = pval->bUnitID;
819 validx = pval->validx;
820
d34bf148
FH		 821 if (!pval->is_cached) {
822 /* Read current value */
888ea7d5
TI		 823 down_read(&mixer->chip->shutdown_rwsem);
824 if (mixer->chip->shutdown)
825 err = -ENODEV;
826 else
827 err = snd_usb_ctl_msg(chip->dev,
d34bf148
FH		 828 usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
829 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
830 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
831 value, val_len);
888ea7d5 832 up_read(&mixer->chip->shutdown_rwsem);
d34bf148
FH		 833 if (err < 0)
834 return err;
835
836 cur_val = value[0];
837 pval->cached_value = cur_val;
838 pval->is_cached = 1;
839 }
840 /* update value if needed */
841 if (cur_val != new_val) {
842 value[0] = new_val;
843 value[1] = 0;
888ea7d5
TI		 844 down_read(&mixer->chip->shutdown_rwsem);
845 if (mixer->chip->shutdown)
846 err = -ENODEV;
847 else
848 err = snd_usb_ctl_msg(chip->dev,
d34bf148
FH		 849 usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
850 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
851 validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
852 value, val_len);
888ea7d5 853 up_read(&mixer->chip->shutdown_rwsem);
d34bf148
FH		 854 if (err < 0)
855 return err;
856
857 pval->cached_value = new_val;
858 pval->is_cached = 1;
859 changed = 1;
860 }
861
862 return changed;
863}
864
d847ce0e
EZ		 865static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
866 int validx, int bUnitID)
d34bf148
FH		 867{
868 static struct snd_kcontrol_new template = {
869 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
870 .name = "Effect Program Switch",
871 .index = 0,
872 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
873 .info = snd_ftu_eff_switch_info,
874 .get = snd_ftu_eff_switch_get,
875 .put = snd_ftu_eff_switch_put
876 };
877
878 int err;
879 struct snd_kcontrol *kctl;
880 struct snd_ftu_eff_switch_priv_val *pval;
881
882 pval = kzalloc(sizeof(*pval), GFP_KERNEL);
883 if (!pval)
884 return -ENOMEM;
885
886 pval->cached_value = 0;
887 pval->is_cached = 0;
888 pval->mixer = mixer;
d847ce0e
EZ		 889 pval->bUnitID = bUnitID;
890 pval->validx = validx;
d34bf148
FH		 891
892 template.private_value = (unsigned long) pval;
893 kctl = snd_ctl_new1(&template, mixer->chip);
894 if (!kctl) {
895 kfree(pval);
896 return -ENOMEM;
897 }
898
899 err = snd_ctl_add(mixer->chip->card, kctl);
900 if (err < 0)
901 return err;
902
903 return 0;
904}
d5a0bf6c 905
cfe8f97c
FH		 906/* Create volume controls for FTU devices*/
907static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
d5a0bf6c
DM		 908{
909 char name[64];
8a4d1d39 910 unsigned int control, cmask;
d5a0bf6c
DM		 911 int in, out, err;
912
8a4d1d39
FH		 913 const unsigned int id = 5;
914 const int val_type = USB_MIXER_S16;
915
d5a0bf6c 916 for (out = 0; out < 8; out++) {
8a4d1d39 917 control = out + 1;
d5a0bf6c 918 for (in = 0; in < 8; in++) {
8a4d1d39 919 cmask = 1 << in;
d5a0bf6c 920 snprintf(name, sizeof(name),
8a4d1d39
FH		 921 "AIn%d - Out%d Capture Volume",
922 in + 1, out + 1);
923 err = snd_create_std_mono_ctl(mixer, id, control,
924 cmask, val_type, name,
25ee7ef8 925 &snd_usb_mixer_vol_tlv);
d5a0bf6c
DM		 926 if (err < 0)
927 return err;
928 }
d5a0bf6c 929 for (in = 8; in < 16; in++) {
8a4d1d39 930 cmask = 1 << in;
d5a0bf6c 931 snprintf(name, sizeof(name),
8a4d1d39
FH		 932 "DIn%d - Out%d Playback Volume",
933 in - 7, out + 1);
934 err = snd_create_std_mono_ctl(mixer, id, control,
935 cmask, val_type, name,
25ee7ef8 936 &snd_usb_mixer_vol_tlv);
d5a0bf6c
DM		 937 if (err < 0)
938 return err;
939 }
940 }
941
942 return 0;
943}
944
d34bf148
FH		 945/* This control needs a volume quirk, see mixer.c */
946static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
947{
948 static const char name[] = "Effect Volume";
949 const unsigned int id = 6;
950 const int val_type = USB_MIXER_U8;
951 const unsigned int control = 2;
952 const unsigned int cmask = 0;
953
954 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
955 name, snd_usb_mixer_vol_tlv);
956}
957
958/* This control needs a volume quirk, see mixer.c */
959static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
960{
961 static const char name[] = "Effect Duration";
962 const unsigned int id = 6;
963 const int val_type = USB_MIXER_S16;
964 const unsigned int control = 3;
965 const unsigned int cmask = 0;
966
967 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
968 name, snd_usb_mixer_vol_tlv);
969}
970
971/* This control needs a volume quirk, see mixer.c */
972static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
973{
974 static const char name[] = "Effect Feedback Volume";
975 const unsigned int id = 6;
976 const int val_type = USB_MIXER_U8;
977 const unsigned int control = 4;
978 const unsigned int cmask = 0;
979
980 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
981 name, NULL);
982}
983
984static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
985{
986 unsigned int cmask;
987 int err, ch;
988 char name[48];
989
990 const unsigned int id = 7;
991 const int val_type = USB_MIXER_S16;
992 const unsigned int control = 7;
993
994 for (ch = 0; ch < 4; ++ch) {
995 cmask = 1 << ch;
996 snprintf(name, sizeof(name),
997 "Effect Return %d Volume", ch + 1);
998 err = snd_create_std_mono_ctl(mixer, id, control,
999 cmask, val_type, name,
1000 snd_usb_mixer_vol_tlv);
1001 if (err < 0)
1002 return err;
1003 }
1004
1005 return 0;
1006}
1007
1008static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1009{
1010 unsigned int cmask;
1011 int err, ch;
1012 char name[48];
1013
1014 const unsigned int id = 5;
1015 const int val_type = USB_MIXER_S16;
1016 const unsigned int control = 9;
1017
1018 for (ch = 0; ch < 8; ++ch) {
1019 cmask = 1 << ch;
1020 snprintf(name, sizeof(name),
1021 "Effect Send AIn%d Volume", ch + 1);
1022 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1023 val_type, name,
1024 snd_usb_mixer_vol_tlv);
1025 if (err < 0)
1026 return err;
1027 }
1028 for (ch = 8; ch < 16; ++ch) {
1029 cmask = 1 << ch;
1030 snprintf(name, sizeof(name),
1031 "Effect Send DIn%d Volume", ch - 7);
1032 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1033 val_type, name,
1034 snd_usb_mixer_vol_tlv);
1035 if (err < 0)
1036 return err;
1037 }
1038 return 0;
1039}
1040
cfe8f97c 1041static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
7536c301 1042{
8a4d1d39 1043 int err;
7536c301 1044
cfe8f97c 1045 err = snd_ftu_create_volume_ctls(mixer);
8a4d1d39
FH		 1046 if (err < 0)
1047 return err;
7536c301 1048
d847ce0e 1049 err = snd_ftu_create_effect_switch(mixer, 1, 6);
d34bf148
FH		 1050 if (err < 0)
1051 return err;
d847ce0e 1052
d34bf148
FH		 1053 err = snd_ftu_create_effect_volume_ctl(mixer);
1054 if (err < 0)
1055 return err;
1056
1057 err = snd_ftu_create_effect_duration_ctl(mixer);
1058 if (err < 0)
1059 return err;
1060
1061 err = snd_ftu_create_effect_feedback_ctl(mixer);
1062 if (err < 0)
1063 return err;
1064
1065 err = snd_ftu_create_effect_return_ctls(mixer);
1066 if (err < 0)
1067 return err;
1068
1069 err = snd_ftu_create_effect_send_ctls(mixer);
1070 if (err < 0)
1071 return err;
1072
8a4d1d39 1073 return 0;
7536c301
MH		 1074}
1075
7b1eda22
DM		 1076void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1077 unsigned char samplerate_id)
1078{
1079 struct usb_mixer_interface *mixer;
1080 struct usb_mixer_elem_info *cval;
1081 int unitid = 12; /* SamleRate ExtensionUnit ID */
1082
1083 list_for_each_entry(mixer, &chip->mixer_list, list) {
1084 cval = mixer->id_elems[unitid];
1085 if (cval) {
1086 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1087 cval->control << 8,
1088 samplerate_id);
1089 snd_usb_mixer_notify_id(mixer, unitid);
1090 }
1091 break;
1092 }
1093}
1094
e9a25e04
MG		 1095/* M-Audio Fast Track C400/C600 */
1096/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
09d8e3a7
EZ		 1097static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1098{
1099 char name[64];
1100 unsigned int cmask, offset;
1101 int out, chan, err;
e9a25e04
MG		 1102 int num_outs = 0;
1103 int num_ins = 0;
09d8e3a7
EZ		 1104
1105 const unsigned int id = 0x40;
1106 const int val_type = USB_MIXER_S16;
1107 const int control = 1;
1108
e9a25e04
MG		 1109 switch (mixer->chip->usb_id) {
1110 case USB_ID(0x0763, 0x2030):
1111 num_outs = 6;
1112 num_ins = 4;
1113 break;
1114 case USB_ID(0x0763, 0x2031):
1115 num_outs = 8;
1116 num_ins = 6;
1117 break;
1118 }
1119
1120 for (chan = 0; chan < num_outs + num_ins; chan++) {
1121 for (out = 0; out < num_outs; out++) {
1122 if (chan < num_outs) {
09d8e3a7
EZ		 1123 snprintf(name, sizeof(name),
1124 "PCM%d-Out%d Playback Volume",
1125 chan + 1, out + 1);
1126 } else {
1127 snprintf(name, sizeof(name),
1128 "In%d-Out%d Playback Volume",
e9a25e04 1129 chan - num_outs + 1, out + 1);
09d8e3a7
EZ		 1130 }
1131
1132 cmask = (out == 0) ? 0 : 1 << (out - 1);
e9a25e04 1133 offset = chan * num_outs;
09d8e3a7
EZ		 1134 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1135 cmask, val_type, offset, name,
1136 &snd_usb_mixer_vol_tlv);
1137 if (err < 0)
1138 return err;
1139 }
1140 }
1141
1142 return 0;
1143}
1144
1145/* This control needs a volume quirk, see mixer.c */
1146static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1147{
1148 static const char name[] = "Effect Volume";
1149 const unsigned int id = 0x43;
1150 const int val_type = USB_MIXER_U8;
1151 const unsigned int control = 3;
1152 const unsigned int cmask = 0;
1153
1154 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1155 name, snd_usb_mixer_vol_tlv);
1156}
1157
1158/* This control needs a volume quirk, see mixer.c */
1159static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1160{
1161 static const char name[] = "Effect Duration";
1162 const unsigned int id = 0x43;
1163 const int val_type = USB_MIXER_S16;
1164 const unsigned int control = 4;
1165 const unsigned int cmask = 0;
1166
1167 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1168 name, snd_usb_mixer_vol_tlv);
1169}
1170
1171/* This control needs a volume quirk, see mixer.c */
1172static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1173{
1174 static const char name[] = "Effect Feedback Volume";
1175 const unsigned int id = 0x43;
1176 const int val_type = USB_MIXER_U8;
1177 const unsigned int control = 5;
1178 const unsigned int cmask = 0;
1179
1180 return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1181 name, NULL);
1182}
1183
1184static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1185{
1186 char name[64];
1187 unsigned int cmask;
1188 int chan, err;
e9a25e04
MG		 1189 int num_outs = 0;
1190 int num_ins = 0;
09d8e3a7
EZ		 1191
1192 const unsigned int id = 0x42;
1193 const int val_type = USB_MIXER_S16;
1194 const int control = 1;
1195
e9a25e04
MG		 1196 switch (mixer->chip->usb_id) {
1197 case USB_ID(0x0763, 0x2030):
1198 num_outs = 6;
1199 num_ins = 4;
1200 break;
1201 case USB_ID(0x0763, 0x2031):
1202 num_outs = 8;
1203 num_ins = 6;
1204 break;
1205 }
1206
1207 for (chan = 0; chan < num_outs + num_ins; chan++) {
1208 if (chan < num_outs) {
09d8e3a7
EZ		 1209 snprintf(name, sizeof(name),
1210 "Effect Send DOut%d",
1211 chan + 1);
1212 } else {
1213 snprintf(name, sizeof(name),
1214 "Effect Send AIn%d",
e9a25e04 1215 chan - num_outs + 1);
09d8e3a7
EZ		 1216 }
1217
1218 cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1219 err = snd_create_std_mono_ctl(mixer, id, control,
1220 cmask, val_type, name,
1221 &snd_usb_mixer_vol_tlv);
1222 if (err < 0)
1223 return err;
1224 }
1225
1226 return 0;
1227}
1228
1229static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1230{
1231 char name[64];
1232 unsigned int cmask;
1233 int chan, err;
e9a25e04
MG		 1234 int num_outs = 0;
1235 int offset = 0;
09d8e3a7
EZ		 1236
1237 const unsigned int id = 0x40;
1238 const int val_type = USB_MIXER_S16;
1239 const int control = 1;
09d8e3a7 1240
e9a25e04
MG		 1241 switch (mixer->chip->usb_id) {
1242 case USB_ID(0x0763, 0x2030):
1243 num_outs = 6;
1244 offset = 0x3c;
1245 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1246 break;
1247 case USB_ID(0x0763, 0x2031):
1248 num_outs = 8;
1249 offset = 0x70;
1250 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1251 break;
1252 }
1253
1254 for (chan = 0; chan < num_outs; chan++) {
09d8e3a7
EZ		 1255 snprintf(name, sizeof(name),
1256 "Effect Return %d",
1257 chan + 1);
1258
e9a25e04
MG		 1259 cmask = (chan == 0) ? 0 :
1260 1 << (chan + (chan % 2) * num_outs - 1);
09d8e3a7
EZ		 1261 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1262 cmask, val_type, offset, name,
1263 &snd_usb_mixer_vol_tlv);
1264 if (err < 0)
1265 return err;
1266 }
1267
1268 return 0;
1269}
1270
1271static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1272{
1273 int err;
1274
1275 err = snd_c400_create_vol_ctls(mixer);
1276 if (err < 0)
1277 return err;
1278
1279 err = snd_c400_create_effect_vol_ctls(mixer);
1280 if (err < 0)
1281 return err;
1282
1283 err = snd_c400_create_effect_ret_vol_ctls(mixer);
1284 if (err < 0)
1285 return err;
1286
1287 err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1288 if (err < 0)
1289 return err;
1290
1291 err = snd_c400_create_effect_volume_ctl(mixer);
1292 if (err < 0)
1293 return err;
1294
1295 err = snd_c400_create_effect_duration_ctl(mixer);
1296 if (err < 0)
1297 return err;
1298
1299 err = snd_c400_create_effect_feedback_ctl(mixer);
1300 if (err < 0)
1301 return err;
1302
1303 return 0;
1304}
1305
b71dad18
MH		 1306/*
1307 * The mixer units for Ebox-44 are corrupt, and even where they
1308 * are valid they presents mono controls as L and R channels of
1309 * stereo. So we provide a good mixer here.
1310 */
e8e7da23 1311static struct std_mono_table ebox44_table[] = {
989b0138
MH		 1312 {
1313 .unitid = 4,
1314 .control = 1,
1315 .cmask = 0x0,
1316 .val_type = USB_MIXER_INV_BOOLEAN,
1317 .name = "Headphone Playback Switch"
1318 },
1319 {
1320 .unitid = 4,
1321 .control = 2,
1322 .cmask = 0x1,
1323 .val_type = USB_MIXER_S16,
1324 .name = "Headphone A Mix Playback Volume"
1325 },
1326 {
1327 .unitid = 4,
1328 .control = 2,
1329 .cmask = 0x2,
1330 .val_type = USB_MIXER_S16,
1331 .name = "Headphone B Mix Playback Volume"
1332 },
b71dad18 1333
989b0138
MH		 1334 {
1335 .unitid = 7,
1336 .control = 1,
1337 .cmask = 0x0,
1338 .val_type = USB_MIXER_INV_BOOLEAN,
1339 .name = "Output Playback Switch"
1340 },
1341 {
1342 .unitid = 7,
1343 .control = 2,
1344 .cmask = 0x1,
1345 .val_type = USB_MIXER_S16,
1346 .name = "Output A Playback Volume"
1347 },
1348 {
1349 .unitid = 7,
1350 .control = 2,
1351 .cmask = 0x2,
1352 .val_type = USB_MIXER_S16,
1353 .name = "Output B Playback Volume"
1354 },
b71dad18 1355
989b0138
MH		 1356 {
1357 .unitid = 10,
1358 .control = 1,
1359 .cmask = 0x0,
1360 .val_type = USB_MIXER_INV_BOOLEAN,
1361 .name = "Input Capture Switch"
1362 },
1363 {
1364 .unitid = 10,
1365 .control = 2,
1366 .cmask = 0x1,
1367 .val_type = USB_MIXER_S16,
1368 .name = "Input A Capture Volume"
1369 },
1370 {
1371 .unitid = 10,
1372 .control = 2,
1373 .cmask = 0x2,
1374 .val_type = USB_MIXER_S16,
1375 .name = "Input B Capture Volume"
1376 },
b71dad18 1377
989b0138 1378 {}
b71dad18
MH		 1379};
1380
066624c6
PR		 1381/* Audio Advantage Micro II findings:
1382 *
1383 * Mapping spdif AES bits to vendor register.bit:
1384 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1385 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1386 * AES2: [0 0 0 0 0 0 0 0]
1387 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1388 * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1389 *
1390 * power on values:
1391 * r2: 0x10
1392 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1393 * just after it to 0xa0, presumably it disables/mutes some analog
1394 * parts when there is no audio.)
1395 * r9: 0x28
1396 *
1397 * Optical transmitter on/off:
1398 * vendor register.bit: 9.1
1399 * 0 - on (0x28 register value)
1400 * 1 - off (0x2a register value)
1401 *
1402 */
1403static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1404 struct snd_ctl_elem_info *uinfo)
1405{
1406 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1407 uinfo->count = 1;
1408 return 0;
1409}
1410
1411static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1412 struct snd_ctl_elem_value *ucontrol)
1413{
1414 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
1415 int err;
1416 struct usb_interface *iface;
1417 struct usb_host_interface *alts;
1418 unsigned int ep;
1419 unsigned char data[3];
1420 int rate;
1421
1422 ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1423 ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1424 ucontrol->value.iec958.status[2] = 0x00;
1425
1426 /* use known values for that card: interface#1 altsetting#1 */
1427 iface = usb_ifnum_to_if(mixer->chip->dev, 1);
1428 alts = &iface->altsetting[1];
1429 ep = get_endpoint(alts, 0)->bEndpointAddress;
1430
1431 err = snd_usb_ctl_msg(mixer->chip->dev,
1432 usb_rcvctrlpipe(mixer->chip->dev, 0),
1433 UAC_GET_CUR,
1434 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1435 UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1436 ep,
1437 data,
1438 sizeof(data));
1439 if (err < 0)
1440 goto end;
1441
1442 rate = data[0] | (data[1] << 8) | (data[2] << 16);
1443 ucontrol->value.iec958.status[3] = (rate == 48000) ?
1444 IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1445
1446 err = 0;
1447end:
1448 return err;
1449}
1450
1451static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1452 struct snd_ctl_elem_value *ucontrol)
1453{
1454 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
1455 int err;
1456 u8 reg;
1457 unsigned long priv_backup = kcontrol->private_value;
1458
1459 reg = ((ucontrol->value.iec958.status[1] & 0x0f) << 4) |
1460 (ucontrol->value.iec958.status[0] & 0x0f);
1461 err = snd_usb_ctl_msg(mixer->chip->dev,
1462 usb_sndctrlpipe(mixer->chip->dev, 0),
1463 UAC_SET_CUR,
1464 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1465 reg,
1466 2,
1467 NULL,
1468 0);
1469 if (err < 0)
1470 goto end;
1471
1472 kcontrol->private_value &= 0xfffff0f0;
1473 kcontrol->private_value |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1474 kcontrol->private_value |= (ucontrol->value.iec958.status[0] & 0x0f);
1475
1476 reg = (ucontrol->value.iec958.status[0] & IEC958_AES0_NONAUDIO) ?
1477 0xa0 : 0x20;
1478 reg |= (ucontrol->value.iec958.status[1] >> 4) & 0x0f;
1479 err = snd_usb_ctl_msg(mixer->chip->dev,
1480 usb_sndctrlpipe(mixer->chip->dev, 0),
1481 UAC_SET_CUR,
1482 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1483 reg,
1484 3,
1485 NULL,
1486 0);
1487 if (err < 0)
1488 goto end;
1489
1490 kcontrol->private_value &= 0xffff0fff;
1491 kcontrol->private_value |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1492
1493 /* The frequency bits in AES3 cannot be set via register access. */
1494
1495 /* Silently ignore any bits from the request that cannot be set. */
1496
1497 err = (priv_backup != kcontrol->private_value);
1498end:
1499 return err;
1500}
1501
1502static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1503 struct snd_ctl_elem_value *ucontrol)
1504{
1505 ucontrol->value.iec958.status[0] = 0x0f;
1506 ucontrol->value.iec958.status[1] = 0xff;
1507 ucontrol->value.iec958.status[2] = 0x00;
1508 ucontrol->value.iec958.status[3] = 0x00;
1509
1510 return 0;
1511}
1512
1513static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1514 struct snd_ctl_elem_value *ucontrol)
1515{
1516 ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1517
1518 return 0;
1519}
1520
1521static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1522 struct snd_ctl_elem_value *ucontrol)
1523{
1524 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
1525 int err;
1526 u8 reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1527
1528 err = snd_usb_ctl_msg(mixer->chip->dev,
1529 usb_sndctrlpipe(mixer->chip->dev, 0),
1530 UAC_SET_CUR,
1531 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1532 reg,
1533 9,
1534 NULL,
1535 0);
1536
1537 if (!err) {
1538 err = (reg != (kcontrol->private_value & 0x0ff));
1539 if (err)
1540 kcontrol->private_value = reg;
1541 }
1542
1543 return err;
1544}
1545
1546static struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1547 {
1548 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1549 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1550 .info = snd_microii_spdif_info,
1551 .get = snd_microii_spdif_default_get,
1552 .put = snd_microii_spdif_default_put,
1553 .private_value = 0x00000100UL,/* reset value */
1554 },
1555 {
1556 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1557 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1558 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1559 .info = snd_microii_spdif_info,
1560 .get = snd_microii_spdif_mask_get,
1561 },
1562 {
1563 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1564 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1565 .info = snd_ctl_boolean_mono_info,
1566 .get = snd_microii_spdif_switch_get,
1567 .put = snd_microii_spdif_switch_put,
1568 .private_value = 0x00000028UL,/* reset value */
1569 }
1570};
1571
1572static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1573{
1574 int err, i;
1575
1576 for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1577 err = snd_ctl_add(mixer->chip->card,
1578 snd_ctl_new1(&snd_microii_mixer_spdif[i], mixer));
1579 if (err < 0)
1580 return err;
1581 }
1582
18e4753f 1583 return 0;
066624c6
PR		 1584}
1585
7b1eda22
DM		 1586int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
1587{
3347b26c 1588 int err = 0;
7b1eda22
DM		 1589 struct snd_info_entry *entry;
1590
1591 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
1592 return err;
1593
3347b26c
DM		 1594 switch (mixer->chip->usb_id) {
1595 case USB_ID(0x041e, 0x3020):
1596 case USB_ID(0x041e, 0x3040):
1597 case USB_ID(0x041e, 0x3042):
7cdd8d73 1598 case USB_ID(0x041e, 0x30df):
3347b26c
DM		 1599 case USB_ID(0x041e, 0x3048):
1600 err = snd_audigy2nx_controls_create(mixer);
1601 if (err < 0)
1602 break;
7b1eda22
DM		 1603 if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
1604 snd_info_set_text_ops(entry, mixer,
1605 snd_audigy2nx_proc_read);
3347b26c 1606 break;
7b1eda22 1607
44832a71
VK		 1608 /* EMU0204 */
1609 case USB_ID(0x041e, 0x3f19):
1610 err = snd_emu0204_controls_create(mixer);
1611 if (err < 0)
1612 break;
1613 break;
1614
09d8e3a7 1615 case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
e9a25e04 1616 case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
09d8e3a7
EZ		 1617 err = snd_c400_create_mixer(mixer);
1618 break;
1619
d5a0bf6c
DM		 1620 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
1621 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
cfe8f97c 1622 err = snd_ftu_create_mixer(mixer);
d5a0bf6c
DM		 1623 break;
1624
1d31affb
DW		 1625 case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
1626 case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
1627 case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
7b1eda22 1628 err = snd_xonar_u1_controls_create(mixer);
3347b26c 1629 break;
7b1eda22 1630
066624c6
PR		 1631 case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
1632 err = snd_microii_controls_create(mixer);
1633 break;
1634
3347b26c 1635 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
54a8c500
DM		 1636 err = snd_nativeinstruments_create_mixer(mixer,
1637 snd_nativeinstruments_ta6_mixers,
1638 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
3347b26c 1639 break;
54a8c500 1640
3347b26c 1641 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
54a8c500
DM		 1642 err = snd_nativeinstruments_create_mixer(mixer,
1643 snd_nativeinstruments_ta10_mixers,
1644 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
3347b26c 1645 break;
7536c301
MH		 1646
1647 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
b71dad18
MH		 1648 /* detection is disabled in mixer_maps.c */
1649 err = snd_create_std_mono_table(mixer, ebox44_table);
7536c301 1650 break;
54a8c500
DM		 1651 }
1652
3347b26c 1653 return err;
7b1eda22
DM		 1654}
1655
1656void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
1657 int unitid)
1658{
1659 if (!mixer->rc_cfg)
1660 return;
1661 /* unit ids specific to Extigy/Audigy 2 NX: */
1662 switch (unitid) {
1663 case 0: /* remote control */
1664 mixer->rc_urb->dev = mixer->chip->dev;
1665 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
1666 break;
1667 case 4: /* digital in jack */
1668 case 7: /* line in jacks */
1669 case 19: /* speaker out jacks */
1670 case 20: /* headphones out jack */
1671 break;
1672 /* live24ext: 4 = line-in jack */
1673 case 3: /* hp-out jack (may actuate Mute) */
1674 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
1675 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
1676 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
1677 break;
1678 default:
0ba41d91 1679 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
7b1eda22
DM		 1680 break;
1681 }
1682}
1683
Linux kernel - Deliverables
This page took 0.209336 seconds and 5 git commands to generate.