?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: 7073/1: debug: augment DEBUG_LL Kconfig help to clarify behaviour
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / usb / mixer_quirks.c
blob3d0f4873112b17d9f5d7bfec90a87fbab2053ae6
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
43 extern 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 */
53 static 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
70 static 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
91 static 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
111 static 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
120 static 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
170 static 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
179 static 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
211 static 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
238 static 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
264 static 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
310 static 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
319 static 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
342 static 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
350 static 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
366 static 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
391 static 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
414 static 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
433 static 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
468 static 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 */
500 static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
501 {
502 kfree(kctl->private_data);
503 kctl->private_data = NULL;
504 }
505
506 static 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
534 static 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
560 void 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
579 int 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
627 void 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
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree