blob: 7dae05d8783e4274266bb5c867e534b342e18614 [file] [log] [blame]
Daniel Mack7b1eda22010-03-11 21:13:22 +01001/*
2 * USB Audio Driver for ALSA
3 *
4 * Quirks and vendor-specific extensions for mixer interfaces
5 *
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7 *
8 * Many codes borrowed from audio.c by
9 * Alan Cox (alan@lxorguk.ukuu.org.uk)
10 * Thomas Sailer (sailer@ife.ee.ethz.ch)
11 *
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>
Stephen Rothwell36db0452010-03-29 16:02:50 +110029#include <linux/slab.h>
Daniel Mack7b1eda22010-03-11 21:13:22 +010030#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"
Daniel Mackf0b5e632010-03-11 21:13:23 +010039#include "mixer.h"
Daniel Mack7b1eda22010-03-11 21:13:22 +010040#include "mixer_quirks.h"
41#include "helper.h"
42
43/*
44 * Sound Blaster remote control configuration
45 *
46 * format of remote control data:
47 * Extigy: xx 00
48 * Audigy 2 NX: 06 80 xx 00 00 00
49 * Live! 24-bit: 06 80 xx yy 22 83
50 */
51static const struct rc_config {
52 u32 usb_id;
53 u8 offset;
54 u8 length;
55 u8 packet_length;
56 u8 min_packet_length; /* minimum accepted length of the URB result */
57 u8 mute_mixer_id;
58 u32 mute_code;
59} rc_configs[] = {
60 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
61 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
62 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
Mandar Joshi97c44b22010-10-24 04:07:00 +000063 { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi */
Daniel Mack7b1eda22010-03-11 21:13:22 +010064 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
65};
66
67static void snd_usb_soundblaster_remote_complete(struct urb *urb)
68{
69 struct usb_mixer_interface *mixer = urb->context;
70 const struct rc_config *rc = mixer->rc_cfg;
71 u32 code;
72
73 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
74 return;
75
76 code = mixer->rc_buffer[rc->offset];
77 if (rc->length == 2)
78 code |= mixer->rc_buffer[rc->offset + 1] << 8;
79
80 /* the Mute button actually changes the mixer control */
81 if (code == rc->mute_code)
82 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
83 mixer->rc_code = code;
84 wmb();
85 wake_up(&mixer->rc_waitq);
86}
87
88static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
89 long count, loff_t *offset)
90{
91 struct usb_mixer_interface *mixer = hw->private_data;
92 int err;
93 u32 rc_code;
94
95 if (count != 1 && count != 4)
96 return -EINVAL;
97 err = wait_event_interruptible(mixer->rc_waitq,
98 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
99 if (err == 0) {
100 if (count == 1)
101 err = put_user(rc_code, buf);
102 else
103 err = put_user(rc_code, (u32 __user *)buf);
104 }
105 return err < 0 ? err : count;
106}
107
108static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
109 poll_table *wait)
110{
111 struct usb_mixer_interface *mixer = hw->private_data;
112
113 poll_wait(file, &mixer->rc_waitq, wait);
114 return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
115}
116
117static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
118{
119 struct snd_hwdep *hwdep;
120 int err, len, i;
121
122 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
123 if (rc_configs[i].usb_id == mixer->chip->usb_id)
124 break;
125 if (i >= ARRAY_SIZE(rc_configs))
126 return 0;
127 mixer->rc_cfg = &rc_configs[i];
128
129 len = mixer->rc_cfg->packet_length;
130
131 init_waitqueue_head(&mixer->rc_waitq);
132 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
133 if (err < 0)
134 return err;
135 snprintf(hwdep->name, sizeof(hwdep->name),
136 "%s remote control", mixer->chip->card->shortname);
137 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
138 hwdep->private_data = mixer;
139 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
140 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
141 hwdep->exclusive = 1;
142
143 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
144 if (!mixer->rc_urb)
145 return -ENOMEM;
146 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
147 if (!mixer->rc_setup_packet) {
148 usb_free_urb(mixer->rc_urb);
149 mixer->rc_urb = NULL;
150 return -ENOMEM;
151 }
152 mixer->rc_setup_packet->bRequestType =
153 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
154 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
155 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
156 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
157 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
158 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
159 usb_rcvctrlpipe(mixer->chip->dev, 0),
160 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
161 snd_usb_soundblaster_remote_complete, mixer);
162 return 0;
163}
164
165#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
166
167static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
168{
169 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
170 int index = kcontrol->private_value;
171
172 ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
173 return 0;
174}
175
176static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
177{
178 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
179 int index = kcontrol->private_value;
180 int value = ucontrol->value.integer.value[0];
181 int err, changed;
182
183 if (value > 1)
184 return -EINVAL;
185 changed = value != mixer->audigy2nx_leds[index];
186 err = snd_usb_ctl_msg(mixer->chip->dev,
187 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
188 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
189 value, index + 2, NULL, 0, 100);
190 if (err < 0)
191 return err;
192 mixer->audigy2nx_leds[index] = value;
193 return changed;
194}
195
196static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
197 {
198 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
199 .name = "CMSS LED Switch",
200 .info = snd_audigy2nx_led_info,
201 .get = snd_audigy2nx_led_get,
202 .put = snd_audigy2nx_led_put,
203 .private_value = 0,
204 },
205 {
206 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
207 .name = "Power LED Switch",
208 .info = snd_audigy2nx_led_info,
209 .get = snd_audigy2nx_led_get,
210 .put = snd_audigy2nx_led_put,
211 .private_value = 1,
212 },
213 {
214 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
215 .name = "Dolby Digital LED Switch",
216 .info = snd_audigy2nx_led_info,
217 .get = snd_audigy2nx_led_get,
218 .put = snd_audigy2nx_led_put,
219 .private_value = 2,
220 },
221};
222
223static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
224{
225 int i, err;
226
227 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
228 if (i > 1 && /* Live24ext has 2 LEDs only */
229 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
230 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
231 break;
232 err = snd_ctl_add(mixer->chip->card,
233 snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
234 if (err < 0)
235 return err;
236 }
237 mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
238 return 0;
239}
240
241static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
242 struct snd_info_buffer *buffer)
243{
244 static const struct sb_jack {
245 int unitid;
246 const char *name;
247 } jacks_audigy2nx[] = {
248 {4, "dig in "},
249 {7, "line in"},
250 {19, "spk out"},
251 {20, "hph out"},
252 {-1, NULL}
253 }, jacks_live24ext[] = {
254 {4, "line in"}, /* &1=Line, &2=Mic*/
255 {3, "hph out"}, /* headphones */
256 {0, "RC "}, /* last command, 6 bytes see rc_config above */
257 {-1, NULL}
258 };
259 const struct sb_jack *jacks;
260 struct usb_mixer_interface *mixer = entry->private_data;
261 int i, err;
262 u8 buf[3];
263
264 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
265 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
266 jacks = jacks_audigy2nx;
267 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
268 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
269 jacks = jacks_live24ext;
270 else
271 return;
272
273 for (i = 0; jacks[i].name; ++i) {
274 snd_iprintf(buffer, "%s: ", jacks[i].name);
275 err = snd_usb_ctl_msg(mixer->chip->dev,
276 usb_rcvctrlpipe(mixer->chip->dev, 0),
277 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
278 USB_RECIP_INTERFACE, 0,
279 jacks[i].unitid << 8, buf, 3, 100);
280 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
281 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
282 else
283 snd_iprintf(buffer, "?\n");
284 }
285}
286
287static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
288 struct snd_ctl_elem_value *ucontrol)
289{
290 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
291
292 ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
293 return 0;
294}
295
296static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
297 struct snd_ctl_elem_value *ucontrol)
298{
299 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
300 u8 old_status, new_status;
301 int err, changed;
302
303 old_status = mixer->xonar_u1_status;
304 if (ucontrol->value.integer.value[0])
305 new_status = old_status | 0x02;
306 else
307 new_status = old_status & ~0x02;
308 changed = new_status != old_status;
309 err = snd_usb_ctl_msg(mixer->chip->dev,
310 usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
311 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
312 50, 0, &new_status, 1, 100);
313 if (err < 0)
314 return err;
315 mixer->xonar_u1_status = new_status;
316 return changed;
317}
318
319static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
320 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
321 .name = "Digital Playback Switch",
322 .info = snd_ctl_boolean_mono_info,
323 .get = snd_xonar_u1_switch_get,
324 .put = snd_xonar_u1_switch_put,
325};
326
327static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
328{
329 int err;
330
331 err = snd_ctl_add(mixer->chip->card,
332 snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
333 if (err < 0)
334 return err;
335 mixer->xonar_u1_status = 0x05;
336 return 0;
337}
338
339void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
340 unsigned char samplerate_id)
341{
342 struct usb_mixer_interface *mixer;
343 struct usb_mixer_elem_info *cval;
344 int unitid = 12; /* SamleRate ExtensionUnit ID */
345
346 list_for_each_entry(mixer, &chip->mixer_list, list) {
347 cval = mixer->id_elems[unitid];
348 if (cval) {
349 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
350 cval->control << 8,
351 samplerate_id);
352 snd_usb_mixer_notify_id(mixer, unitid);
353 }
354 break;
355 }
356}
357
358int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
359{
360 int err;
361 struct snd_info_entry *entry;
362
363 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
364 return err;
365
366 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
367 mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
368 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
369 if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
370 return err;
371 if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
372 snd_info_set_text_ops(entry, mixer,
373 snd_audigy2nx_proc_read);
374 }
375
376 if (mixer->chip->usb_id == USB_ID(0x0b05, 0x1739) ||
377 mixer->chip->usb_id == USB_ID(0x0b05, 0x1743)) {
378 err = snd_xonar_u1_controls_create(mixer);
379 if (err < 0)
380 return err;
381 }
382
383 return 0;
384}
385
386void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
387 int unitid)
388{
389 if (!mixer->rc_cfg)
390 return;
391 /* unit ids specific to Extigy/Audigy 2 NX: */
392 switch (unitid) {
393 case 0: /* remote control */
394 mixer->rc_urb->dev = mixer->chip->dev;
395 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
396 break;
397 case 4: /* digital in jack */
398 case 7: /* line in jacks */
399 case 19: /* speaker out jacks */
400 case 20: /* headphones out jack */
401 break;
402 /* live24ext: 4 = line-in jack */
403 case 3: /* hp-out jack (may actuate Mute) */
404 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
405 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
406 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
407 break;
408 default:
409 snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
410 break;
411 }
412}
413