2 * USB Audio Driver for ALSA
4 * Quirks and vendor-specific extensions for mixer interfaces
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
8 * Many codes borrowed from audio.c by
9 * Alan Cox (alan@lxorguk.ukuu.org.uk)
10 * Thomas Sailer (sailer@ife.ee.ethz.ch)
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.
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.
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
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/usb.h>
31 #include <linux/usb/audio.h>
33 #include <sound/core.h>
34 #include <sound/control.h>
35 #include <sound/hwdep.h>
36 #include <sound/info.h>
40 #include "mixer_quirks.h"
43 extern struct snd_kcontrol_new
*snd_usb_feature_unit_ctl
;
45 /* private_free callback */
46 static void usb_mixer_elem_free(struct snd_kcontrol
*kctl
)
48 kfree(kctl
->private_data
);
49 kctl
->private_data
= NULL
;
52 /* This function allows for the creation of standard UAC controls.
53 * See the quirks for M-Audio FTUs or Ebox-44.
54 * If you don't want to set a TLV callback pass NULL.
56 * Since there doesn't seem to be a devices that needs a multichannel
57 * version, we keep it mono for simplicity.
59 static int snd_create_std_mono_ctl(struct usb_mixer_interface
*mixer
,
65 snd_kcontrol_tlv_rw_t
*tlv_callback
)
68 struct usb_mixer_elem_info
*cval
;
69 struct snd_kcontrol
*kctl
;
71 cval
= kzalloc(sizeof(*cval
), GFP_KERNEL
);
77 cval
->val_type
= val_type
;
79 cval
->control
= control
;
82 /* get_min_max() is called only for integer volumes later,
83 * so provide a short-cut for booleans */
91 kctl
= snd_ctl_new1(snd_usb_feature_unit_ctl
, cval
);
98 snprintf(kctl
->id
.name
, sizeof(kctl
->id
.name
), name
);
99 kctl
->private_free
= usb_mixer_elem_free
;
103 kctl
->tlv
.c
= tlv_callback
;
104 kctl
->vd
[0].access
|=
105 SNDRV_CTL_ELEM_ACCESS_TLV_READ
|
106 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
;
108 /* Add control to mixer */
109 err
= snd_usb_mixer_add_control(mixer
, kctl
);
117 * Sound Blaster remote control configuration
119 * format of remote control data:
121 * Audigy 2 NX: 06 80 xx 00 00 00
122 * Live! 24-bit: 06 80 xx yy 22 83
124 static const struct rc_config
{
129 u8 min_packet_length
; /* minimum accepted length of the URB result */
133 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
134 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
135 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
136 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
137 { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
138 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
141 static void snd_usb_soundblaster_remote_complete(struct urb
*urb
)
143 struct usb_mixer_interface
*mixer
= urb
->context
;
144 const struct rc_config
*rc
= mixer
->rc_cfg
;
147 if (urb
->status
< 0 || urb
->actual_length
< rc
->min_packet_length
)
150 code
= mixer
->rc_buffer
[rc
->offset
];
152 code
|= mixer
->rc_buffer
[rc
->offset
+ 1] << 8;
154 /* the Mute button actually changes the mixer control */
155 if (code
== rc
->mute_code
)
156 snd_usb_mixer_notify_id(mixer
, rc
->mute_mixer_id
);
157 mixer
->rc_code
= code
;
159 wake_up(&mixer
->rc_waitq
);
162 static long snd_usb_sbrc_hwdep_read(struct snd_hwdep
*hw
, char __user
*buf
,
163 long count
, loff_t
*offset
)
165 struct usb_mixer_interface
*mixer
= hw
->private_data
;
169 if (count
!= 1 && count
!= 4)
171 err
= wait_event_interruptible(mixer
->rc_waitq
,
172 (rc_code
= xchg(&mixer
->rc_code
, 0)) != 0);
175 err
= put_user(rc_code
, buf
);
177 err
= put_user(rc_code
, (u32 __user
*)buf
);
179 return err
< 0 ? err
: count
;
182 static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep
*hw
, struct file
*file
,
185 struct usb_mixer_interface
*mixer
= hw
->private_data
;
187 poll_wait(file
, &mixer
->rc_waitq
, wait
);
188 return mixer
->rc_code
? POLLIN
| POLLRDNORM
: 0;
191 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface
*mixer
)
193 struct snd_hwdep
*hwdep
;
196 for (i
= 0; i
< ARRAY_SIZE(rc_configs
); ++i
)
197 if (rc_configs
[i
].usb_id
== mixer
->chip
->usb_id
)
199 if (i
>= ARRAY_SIZE(rc_configs
))
201 mixer
->rc_cfg
= &rc_configs
[i
];
203 len
= mixer
->rc_cfg
->packet_length
;
205 init_waitqueue_head(&mixer
->rc_waitq
);
206 err
= snd_hwdep_new(mixer
->chip
->card
, "SB remote control", 0, &hwdep
);
209 snprintf(hwdep
->name
, sizeof(hwdep
->name
),
210 "%s remote control", mixer
->chip
->card
->shortname
);
211 hwdep
->iface
= SNDRV_HWDEP_IFACE_SB_RC
;
212 hwdep
->private_data
= mixer
;
213 hwdep
->ops
.read
= snd_usb_sbrc_hwdep_read
;
214 hwdep
->ops
.poll
= snd_usb_sbrc_hwdep_poll
;
215 hwdep
->exclusive
= 1;
217 mixer
->rc_urb
= usb_alloc_urb(0, GFP_KERNEL
);
220 mixer
->rc_setup_packet
= kmalloc(sizeof(*mixer
->rc_setup_packet
), GFP_KERNEL
);
221 if (!mixer
->rc_setup_packet
) {
222 usb_free_urb(mixer
->rc_urb
);
223 mixer
->rc_urb
= NULL
;
226 mixer
->rc_setup_packet
->bRequestType
=
227 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
;
228 mixer
->rc_setup_packet
->bRequest
= UAC_GET_MEM
;
229 mixer
->rc_setup_packet
->wValue
= cpu_to_le16(0);
230 mixer
->rc_setup_packet
->wIndex
= cpu_to_le16(0);
231 mixer
->rc_setup_packet
->wLength
= cpu_to_le16(len
);
232 usb_fill_control_urb(mixer
->rc_urb
, mixer
->chip
->dev
,
233 usb_rcvctrlpipe(mixer
->chip
->dev
, 0),
234 (u8
*)mixer
->rc_setup_packet
, mixer
->rc_buffer
, len
,
235 snd_usb_soundblaster_remote_complete
, mixer
);
239 #define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
241 static int snd_audigy2nx_led_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
243 struct usb_mixer_interface
*mixer
= snd_kcontrol_chip(kcontrol
);
244 int index
= kcontrol
->private_value
;
246 ucontrol
->value
.integer
.value
[0] = mixer
->audigy2nx_leds
[index
];
250 static int snd_audigy2nx_led_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
252 struct usb_mixer_interface
*mixer
= snd_kcontrol_chip(kcontrol
);
253 int index
= kcontrol
->private_value
;
254 int value
= ucontrol
->value
.integer
.value
[0];
259 changed
= value
!= mixer
->audigy2nx_leds
[index
];
260 if (mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3042))
261 err
= snd_usb_ctl_msg(mixer
->chip
->dev
,
262 usb_sndctrlpipe(mixer
->chip
->dev
, 0), 0x24,
263 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_OTHER
,
265 /* USB X-Fi S51 Pro */
266 if (mixer
->chip
->usb_id
== USB_ID(0x041e, 0x30df))
267 err
= snd_usb_ctl_msg(mixer
->chip
->dev
,
268 usb_sndctrlpipe(mixer
->chip
->dev
, 0), 0x24,
269 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_OTHER
,
272 err
= snd_usb_ctl_msg(mixer
->chip
->dev
,
273 usb_sndctrlpipe(mixer
->chip
->dev
, 0), 0x24,
274 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_OTHER
,
275 value
, index
+ 2, NULL
, 0);
278 mixer
->audigy2nx_leds
[index
] = value
;
282 static struct snd_kcontrol_new snd_audigy2nx_controls
[] = {
284 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
285 .name
= "CMSS LED Switch",
286 .info
= snd_audigy2nx_led_info
,
287 .get
= snd_audigy2nx_led_get
,
288 .put
= snd_audigy2nx_led_put
,
292 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
293 .name
= "Power LED Switch",
294 .info
= snd_audigy2nx_led_info
,
295 .get
= snd_audigy2nx_led_get
,
296 .put
= snd_audigy2nx_led_put
,
300 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
301 .name
= "Dolby Digital LED Switch",
302 .info
= snd_audigy2nx_led_info
,
303 .get
= snd_audigy2nx_led_get
,
304 .put
= snd_audigy2nx_led_put
,
309 static int snd_audigy2nx_controls_create(struct usb_mixer_interface
*mixer
)
313 for (i
= 0; i
< ARRAY_SIZE(snd_audigy2nx_controls
); ++i
) {
314 /* USB X-Fi S51 doesn't have a CMSS LED */
315 if ((mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3042)) && i
== 0)
317 /* USB X-Fi S51 Pro doesn't have one either */
318 if ((mixer
->chip
->usb_id
== USB_ID(0x041e, 0x30df)) && i
== 0)
320 if (i
> 1 && /* Live24ext has 2 LEDs only */
321 (mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3040) ||
322 mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3042) ||
323 mixer
->chip
->usb_id
== USB_ID(0x041e, 0x30df) ||
324 mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3048)))
326 err
= snd_ctl_add(mixer
->chip
->card
,
327 snd_ctl_new1(&snd_audigy2nx_controls
[i
], mixer
));
331 mixer
->audigy2nx_leds
[1] = 1; /* Power LED is on by default */
335 static void snd_audigy2nx_proc_read(struct snd_info_entry
*entry
,
336 struct snd_info_buffer
*buffer
)
338 static const struct sb_jack
{
341 } jacks_audigy2nx
[] = {
347 }, jacks_live24ext
[] = {
348 {4, "line in"}, /* &1=Line, &2=Mic*/
349 {3, "hph out"}, /* headphones */
350 {0, "RC "}, /* last command, 6 bytes see rc_config above */
353 const struct sb_jack
*jacks
;
354 struct usb_mixer_interface
*mixer
= entry
->private_data
;
358 snd_iprintf(buffer
, "%s jacks\n\n", mixer
->chip
->card
->shortname
);
359 if (mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3020))
360 jacks
= jacks_audigy2nx
;
361 else if (mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3040) ||
362 mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3048))
363 jacks
= jacks_live24ext
;
367 for (i
= 0; jacks
[i
].name
; ++i
) {
368 snd_iprintf(buffer
, "%s: ", jacks
[i
].name
);
369 err
= snd_usb_ctl_msg(mixer
->chip
->dev
,
370 usb_rcvctrlpipe(mixer
->chip
->dev
, 0),
371 UAC_GET_MEM
, USB_DIR_IN
| USB_TYPE_CLASS
|
372 USB_RECIP_INTERFACE
, 0,
373 jacks
[i
].unitid
<< 8, buf
, 3);
374 if (err
== 3 && (buf
[0] == 3 || buf
[0] == 6))
375 snd_iprintf(buffer
, "%02x %02x\n", buf
[1], buf
[2]);
377 snd_iprintf(buffer
, "?\n");
381 static int snd_xonar_u1_switch_get(struct snd_kcontrol
*kcontrol
,
382 struct snd_ctl_elem_value
*ucontrol
)
384 struct usb_mixer_interface
*mixer
= snd_kcontrol_chip(kcontrol
);
386 ucontrol
->value
.integer
.value
[0] = !!(mixer
->xonar_u1_status
& 0x02);
390 static int snd_xonar_u1_switch_put(struct snd_kcontrol
*kcontrol
,
391 struct snd_ctl_elem_value
*ucontrol
)
393 struct usb_mixer_interface
*mixer
= snd_kcontrol_chip(kcontrol
);
394 u8 old_status
, new_status
;
397 old_status
= mixer
->xonar_u1_status
;
398 if (ucontrol
->value
.integer
.value
[0])
399 new_status
= old_status
| 0x02;
401 new_status
= old_status
& ~0x02;
402 changed
= new_status
!= old_status
;
403 err
= snd_usb_ctl_msg(mixer
->chip
->dev
,
404 usb_sndctrlpipe(mixer
->chip
->dev
, 0), 0x08,
405 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_OTHER
,
406 50, 0, &new_status
, 1);
409 mixer
->xonar_u1_status
= new_status
;
413 static struct snd_kcontrol_new snd_xonar_u1_output_switch
= {
414 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
415 .name
= "Digital Playback Switch",
416 .info
= snd_ctl_boolean_mono_info
,
417 .get
= snd_xonar_u1_switch_get
,
418 .put
= snd_xonar_u1_switch_put
,
421 static int snd_xonar_u1_controls_create(struct usb_mixer_interface
*mixer
)
425 err
= snd_ctl_add(mixer
->chip
->card
,
426 snd_ctl_new1(&snd_xonar_u1_output_switch
, mixer
));
429 mixer
->xonar_u1_status
= 0x05;
433 /* Native Instruments device quirks */
435 #define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
437 static int snd_nativeinstruments_control_get(struct snd_kcontrol
*kcontrol
,
438 struct snd_ctl_elem_value
*ucontrol
)
440 struct usb_mixer_interface
*mixer
= snd_kcontrol_chip(kcontrol
);
441 struct usb_device
*dev
= mixer
->chip
->dev
;
442 u8 bRequest
= (kcontrol
->private_value
>> 16) & 0xff;
443 u16 wIndex
= kcontrol
->private_value
& 0xffff;
446 int ret
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), bRequest
,
447 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
| USB_DIR_IN
,
448 0, cpu_to_le16(wIndex
),
449 &tmp
, sizeof(tmp
), 1000);
453 "unable to issue vendor read request (ret = %d)", ret
);
457 ucontrol
->value
.integer
.value
[0] = tmp
;
462 static int snd_nativeinstruments_control_put(struct snd_kcontrol
*kcontrol
,
463 struct snd_ctl_elem_value
*ucontrol
)
465 struct usb_mixer_interface
*mixer
= snd_kcontrol_chip(kcontrol
);
466 struct usb_device
*dev
= mixer
->chip
->dev
;
467 u8 bRequest
= (kcontrol
->private_value
>> 16) & 0xff;
468 u16 wIndex
= kcontrol
->private_value
& 0xffff;
469 u16 wValue
= ucontrol
->value
.integer
.value
[0];
471 int ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), bRequest
,
472 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
| USB_DIR_OUT
,
473 cpu_to_le16(wValue
), cpu_to_le16(wIndex
),
478 "unable to issue vendor write request (ret = %d)", ret
);
485 static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers
[] = {
487 .name
= "Direct Thru Channel A",
488 .private_value
= _MAKE_NI_CONTROL(0x01, 0x03),
491 .name
= "Direct Thru Channel B",
492 .private_value
= _MAKE_NI_CONTROL(0x01, 0x05),
495 .name
= "Phono Input Channel A",
496 .private_value
= _MAKE_NI_CONTROL(0x02, 0x03),
499 .name
= "Phono Input Channel B",
500 .private_value
= _MAKE_NI_CONTROL(0x02, 0x05),
504 static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers
[] = {
506 .name
= "Direct Thru Channel A",
507 .private_value
= _MAKE_NI_CONTROL(0x01, 0x03),
510 .name
= "Direct Thru Channel B",
511 .private_value
= _MAKE_NI_CONTROL(0x01, 0x05),
514 .name
= "Direct Thru Channel C",
515 .private_value
= _MAKE_NI_CONTROL(0x01, 0x07),
518 .name
= "Direct Thru Channel D",
519 .private_value
= _MAKE_NI_CONTROL(0x01, 0x09),
522 .name
= "Phono Input Channel A",
523 .private_value
= _MAKE_NI_CONTROL(0x02, 0x03),
526 .name
= "Phono Input Channel B",
527 .private_value
= _MAKE_NI_CONTROL(0x02, 0x05),
530 .name
= "Phono Input Channel C",
531 .private_value
= _MAKE_NI_CONTROL(0x02, 0x07),
534 .name
= "Phono Input Channel D",
535 .private_value
= _MAKE_NI_CONTROL(0x02, 0x09),
539 static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface
*mixer
,
540 const struct snd_kcontrol_new
*kc
,
544 struct snd_kcontrol_new
template = {
545 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
546 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
547 .get
= snd_nativeinstruments_control_get
,
548 .put
= snd_nativeinstruments_control_put
,
549 .info
= snd_ctl_boolean_mono_info
,
552 for (i
= 0; i
< count
; i
++) {
553 struct snd_kcontrol
*c
;
555 template.name
= kc
[i
].name
;
556 template.private_value
= kc
[i
].private_value
;
558 c
= snd_ctl_new1(&template, mixer
);
559 err
= snd_ctl_add(mixer
->chip
->card
, c
);
568 /* M-Audio FastTrack Ultra quirks */
569 /* FTU Effect switch */
570 struct snd_ftu_eff_switch_priv_val
{
571 struct usb_mixer_interface
*mixer
;
576 static int snd_ftu_eff_switch_info(struct snd_kcontrol
*kcontrol
,
577 struct snd_ctl_elem_info
*uinfo
)
579 static const char *texts
[8] = {"Room 1",
589 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
591 uinfo
->value
.enumerated
.items
= 8;
592 if (uinfo
->value
.enumerated
.item
> 7)
593 uinfo
->value
.enumerated
.item
= 7;
594 strcpy(uinfo
->value
.enumerated
.name
,
595 texts
[uinfo
->value
.enumerated
.item
]);
600 static int snd_ftu_eff_switch_get(struct snd_kcontrol
*kctl
,
601 struct snd_ctl_elem_value
*ucontrol
)
603 struct snd_usb_audio
*chip
;
604 struct usb_mixer_interface
*mixer
;
605 struct snd_ftu_eff_switch_priv_val
*pval
;
607 unsigned char value
[2];
610 const int validx
= 1;
611 const int val_len
= 2;
616 pval
= (struct snd_ftu_eff_switch_priv_val
*)
619 if (pval
->is_cached
) {
620 ucontrol
->value
.enumerated
.item
[0] = pval
->cached_value
;
624 mixer
= (struct usb_mixer_interface
*) pval
->mixer
;
625 if (snd_BUG_ON(!mixer
))
628 chip
= (struct snd_usb_audio
*) mixer
->chip
;
629 if (snd_BUG_ON(!chip
))
633 err
= snd_usb_ctl_msg(chip
->dev
,
634 usb_rcvctrlpipe(chip
->dev
, 0), UAC_GET_CUR
,
635 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
636 validx
<< 8, snd_usb_ctrl_intf(chip
) | (id
<< 8),
641 ucontrol
->value
.enumerated
.item
[0] = value
[0];
642 pval
->cached_value
= value
[0];
648 static int snd_ftu_eff_switch_put(struct snd_kcontrol
*kctl
,
649 struct snd_ctl_elem_value
*ucontrol
)
651 struct snd_usb_audio
*chip
;
652 struct snd_ftu_eff_switch_priv_val
*pval
;
654 struct usb_mixer_interface
*mixer
;
655 int changed
, cur_val
, err
, new_val
;
656 unsigned char value
[2];
660 const int validx
= 1;
661 const int val_len
= 2;
665 pval
= (struct snd_ftu_eff_switch_priv_val
*)
667 cur_val
= pval
->cached_value
;
668 new_val
= ucontrol
->value
.enumerated
.item
[0];
670 mixer
= (struct usb_mixer_interface
*) pval
->mixer
;
671 if (snd_BUG_ON(!mixer
))
674 chip
= (struct snd_usb_audio
*) mixer
->chip
;
675 if (snd_BUG_ON(!chip
))
678 if (!pval
->is_cached
) {
679 /* Read current value */
680 err
= snd_usb_ctl_msg(chip
->dev
,
681 usb_rcvctrlpipe(chip
->dev
, 0), UAC_GET_CUR
,
682 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
683 validx
<< 8, snd_usb_ctrl_intf(chip
) | (id
<< 8),
689 pval
->cached_value
= cur_val
;
692 /* update value if needed */
693 if (cur_val
!= new_val
) {
696 err
= snd_usb_ctl_msg(chip
->dev
,
697 usb_sndctrlpipe(chip
->dev
, 0), UAC_SET_CUR
,
698 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
699 validx
<< 8, snd_usb_ctrl_intf(chip
) | (id
<< 8),
704 pval
->cached_value
= new_val
;
712 static int snd_ftu_create_effect_switch(struct usb_mixer_interface
*mixer
)
714 static struct snd_kcontrol_new
template = {
715 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
716 .name
= "Effect Program Switch",
718 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
719 .info
= snd_ftu_eff_switch_info
,
720 .get
= snd_ftu_eff_switch_get
,
721 .put
= snd_ftu_eff_switch_put
725 struct snd_kcontrol
*kctl
;
726 struct snd_ftu_eff_switch_priv_val
*pval
;
728 pval
= kzalloc(sizeof(*pval
), GFP_KERNEL
);
732 pval
->cached_value
= 0;
736 template.private_value
= (unsigned long) pval
;
737 kctl
= snd_ctl_new1(&template, mixer
->chip
);
743 err
= snd_ctl_add(mixer
->chip
->card
, kctl
);
750 /* Create volume controls for FTU devices*/
751 static int snd_ftu_create_volume_ctls(struct usb_mixer_interface
*mixer
)
754 unsigned int control
, cmask
;
757 const unsigned int id
= 5;
758 const int val_type
= USB_MIXER_S16
;
760 for (out
= 0; out
< 8; out
++) {
762 for (in
= 0; in
< 8; in
++) {
764 snprintf(name
, sizeof(name
),
765 "AIn%d - Out%d Capture Volume",
767 err
= snd_create_std_mono_ctl(mixer
, id
, control
,
768 cmask
, val_type
, name
,
769 &snd_usb_mixer_vol_tlv
);
773 for (in
= 8; in
< 16; in
++) {
775 snprintf(name
, sizeof(name
),
776 "DIn%d - Out%d Playback Volume",
778 err
= snd_create_std_mono_ctl(mixer
, id
, control
,
779 cmask
, val_type
, name
,
780 &snd_usb_mixer_vol_tlv
);
789 /* This control needs a volume quirk, see mixer.c */
790 static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface
*mixer
)
792 static const char name
[] = "Effect Volume";
793 const unsigned int id
= 6;
794 const int val_type
= USB_MIXER_U8
;
795 const unsigned int control
= 2;
796 const unsigned int cmask
= 0;
798 return snd_create_std_mono_ctl(mixer
, id
, control
, cmask
, val_type
,
799 name
, snd_usb_mixer_vol_tlv
);
802 /* This control needs a volume quirk, see mixer.c */
803 static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface
*mixer
)
805 static const char name
[] = "Effect Duration";
806 const unsigned int id
= 6;
807 const int val_type
= USB_MIXER_S16
;
808 const unsigned int control
= 3;
809 const unsigned int cmask
= 0;
811 return snd_create_std_mono_ctl(mixer
, id
, control
, cmask
, val_type
,
812 name
, snd_usb_mixer_vol_tlv
);
815 /* This control needs a volume quirk, see mixer.c */
816 static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface
*mixer
)
818 static const char name
[] = "Effect Feedback Volume";
819 const unsigned int id
= 6;
820 const int val_type
= USB_MIXER_U8
;
821 const unsigned int control
= 4;
822 const unsigned int cmask
= 0;
824 return snd_create_std_mono_ctl(mixer
, id
, control
, cmask
, val_type
,
828 static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface
*mixer
)
834 const unsigned int id
= 7;
835 const int val_type
= USB_MIXER_S16
;
836 const unsigned int control
= 7;
838 for (ch
= 0; ch
< 4; ++ch
) {
840 snprintf(name
, sizeof(name
),
841 "Effect Return %d Volume", ch
+ 1);
842 err
= snd_create_std_mono_ctl(mixer
, id
, control
,
843 cmask
, val_type
, name
,
844 snd_usb_mixer_vol_tlv
);
852 static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface
*mixer
)
858 const unsigned int id
= 5;
859 const int val_type
= USB_MIXER_S16
;
860 const unsigned int control
= 9;
862 for (ch
= 0; ch
< 8; ++ch
) {
864 snprintf(name
, sizeof(name
),
865 "Effect Send AIn%d Volume", ch
+ 1);
866 err
= snd_create_std_mono_ctl(mixer
, id
, control
, cmask
,
868 snd_usb_mixer_vol_tlv
);
872 for (ch
= 8; ch
< 16; ++ch
) {
874 snprintf(name
, sizeof(name
),
875 "Effect Send DIn%d Volume", ch
- 7);
876 err
= snd_create_std_mono_ctl(mixer
, id
, control
, cmask
,
878 snd_usb_mixer_vol_tlv
);
885 static int snd_ftu_create_mixer(struct usb_mixer_interface
*mixer
)
889 err
= snd_ftu_create_volume_ctls(mixer
);
893 err
= snd_ftu_create_effect_switch(mixer
);
896 err
= snd_ftu_create_effect_volume_ctl(mixer
);
900 err
= snd_ftu_create_effect_duration_ctl(mixer
);
904 err
= snd_ftu_create_effect_feedback_ctl(mixer
);
908 err
= snd_ftu_create_effect_return_ctls(mixer
);
912 err
= snd_ftu_create_effect_send_ctls(mixer
);
921 * Create mixer for Electrix Ebox-44
923 * The mixer units from this device are corrupt, and even where they
924 * are valid they presents mono controls as L and R channels of
925 * stereo. So we create a good mixer in code.
928 static int snd_ebox44_create_mixer(struct usb_mixer_interface
*mixer
)
932 err
= snd_create_std_mono_ctl(mixer
, 4, 1, 0x0, USB_MIXER_INV_BOOLEAN
,
933 "Headphone Playback Switch", NULL
);
936 err
= snd_create_std_mono_ctl(mixer
, 4, 2, 0x1, USB_MIXER_S16
,
937 "Headphone A Mix Playback Volume", NULL
);
940 err
= snd_create_std_mono_ctl(mixer
, 4, 2, 0x2, USB_MIXER_S16
,
941 "Headphone B Mix Playback Volume", NULL
);
945 err
= snd_create_std_mono_ctl(mixer
, 7, 1, 0x0, USB_MIXER_INV_BOOLEAN
,
946 "Output Playback Switch", NULL
);
949 err
= snd_create_std_mono_ctl(mixer
, 7, 2, 0x1, USB_MIXER_S16
,
950 "Output A Playback Volume", NULL
);
953 err
= snd_create_std_mono_ctl(mixer
, 7, 2, 0x2, USB_MIXER_S16
,
954 "Output B Playback Volume", NULL
);
958 err
= snd_create_std_mono_ctl(mixer
, 10, 1, 0x0, USB_MIXER_INV_BOOLEAN
,
959 "Input Capture Switch", NULL
);
962 err
= snd_create_std_mono_ctl(mixer
, 10, 2, 0x1, USB_MIXER_S16
,
963 "Input A Capture Volume", NULL
);
966 err
= snd_create_std_mono_ctl(mixer
, 10, 2, 0x2, USB_MIXER_S16
,
967 "Input B Capture Volume", NULL
);
974 void snd_emuusb_set_samplerate(struct snd_usb_audio
*chip
,
975 unsigned char samplerate_id
)
977 struct usb_mixer_interface
*mixer
;
978 struct usb_mixer_elem_info
*cval
;
979 int unitid
= 12; /* SamleRate ExtensionUnit ID */
981 list_for_each_entry(mixer
, &chip
->mixer_list
, list
) {
982 cval
= mixer
->id_elems
[unitid
];
984 snd_usb_mixer_set_ctl_value(cval
, UAC_SET_CUR
,
987 snd_usb_mixer_notify_id(mixer
, unitid
);
993 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface
*mixer
)
996 struct snd_info_entry
*entry
;
998 if ((err
= snd_usb_soundblaster_remote_init(mixer
)) < 0)
1001 switch (mixer
->chip
->usb_id
) {
1002 case USB_ID(0x041e, 0x3020):
1003 case USB_ID(0x041e, 0x3040):
1004 case USB_ID(0x041e, 0x3042):
1005 case USB_ID(0x041e, 0x30df):
1006 case USB_ID(0x041e, 0x3048):
1007 err
= snd_audigy2nx_controls_create(mixer
);
1010 if (!snd_card_proc_new(mixer
->chip
->card
, "audigy2nx", &entry
))
1011 snd_info_set_text_ops(entry
, mixer
,
1012 snd_audigy2nx_proc_read
);
1015 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
1016 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
1017 err
= snd_ftu_create_mixer(mixer
);
1020 case USB_ID(0x0b05, 0x1739):
1021 case USB_ID(0x0b05, 0x1743):
1022 err
= snd_xonar_u1_controls_create(mixer
);
1025 case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
1026 err
= snd_nativeinstruments_create_mixer(mixer
,
1027 snd_nativeinstruments_ta6_mixers
,
1028 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers
));
1031 case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
1032 err
= snd_nativeinstruments_create_mixer(mixer
,
1033 snd_nativeinstruments_ta10_mixers
,
1034 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers
));
1037 case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
1038 err
= snd_ebox44_create_mixer(mixer
);
1045 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface
*mixer
,
1050 /* unit ids specific to Extigy/Audigy 2 NX: */
1052 case 0: /* remote control */
1053 mixer
->rc_urb
->dev
= mixer
->chip
->dev
;
1054 usb_submit_urb(mixer
->rc_urb
, GFP_ATOMIC
);
1056 case 4: /* digital in jack */
1057 case 7: /* line in jacks */
1058 case 19: /* speaker out jacks */
1059 case 20: /* headphones out jack */
1061 /* live24ext: 4 = line-in jack */
1062 case 3: /* hp-out jack (may actuate Mute) */
1063 if (mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3040) ||
1064 mixer
->chip
->usb_id
== USB_ID(0x041e, 0x3048))
1065 snd_usb_mixer_notify_id(mixer
, mixer
->rc_cfg
->mute_mixer_id
);
1068 snd_printd(KERN_DEBUG
"memory change in unknown unit %d\n", unitid
);