aboutsummaryrefslogtreecommitdiffstats
path: root/sound/usb
diff options
context:
space:
mode:
authorJaroslav Kysela <perex@perex.cz>2010-04-16 04:37:41 -0400
committerJaroslav Kysela <perex@perex.cz>2010-04-16 04:37:41 -0400
commitf09d045e2a61d2fdae3d0127208f18c9f44acf80 (patch)
treeedbe84444ac4e6f1d52aa87aef2e2e7d008fcb16 /sound/usb
parentdc57da3875f527b1cc195ea4ce5bd32e1e68433d (diff)
parent27762b2ce16d5c6f7bc8ab1aad1b9179076f997a (diff)
Merge branch 'topic/usb' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6 into devel
Diffstat (limited to 'sound/usb')
-rw-r--r--sound/usb/Kconfig4
-rw-r--r--sound/usb/Makefile26
-rw-r--r--sound/usb/caiaq/control.c99
-rw-r--r--sound/usb/caiaq/device.c8
-rw-r--r--sound/usb/caiaq/device.h24
-rw-r--r--sound/usb/caiaq/input.c163
-rw-r--r--sound/usb/card.c652
-rw-r--r--sound/usb/card.h105
-rw-r--r--sound/usb/debug.h15
-rw-r--r--sound/usb/endpoint.c362
-rw-r--r--sound/usb/endpoint.h11
-rw-r--r--sound/usb/format.c432
-rw-r--r--sound/usb/format.h8
-rw-r--r--sound/usb/helper.c113
-rw-r--r--sound/usb/helper.h32
-rw-r--r--sound/usb/midi.c (renamed from sound/usb/usbmidi.c)27
-rw-r--r--sound/usb/midi.h48
-rw-r--r--sound/usb/misc/Makefile2
-rw-r--r--sound/usb/misc/ua101.c (renamed from sound/usb/ua101.c)3
-rw-r--r--sound/usb/mixer.c (renamed from sound/usb/usbmixer.c)847
-rw-r--r--sound/usb/mixer.h55
-rw-r--r--sound/usb/mixer_maps.c (renamed from sound/usb/usbmixer_maps.c)4
-rw-r--r--sound/usb/mixer_quirks.c412
-rw-r--r--sound/usb/mixer_quirks.h13
-rw-r--r--sound/usb/pcm.c935
-rw-r--r--sound/usb/pcm.h14
-rw-r--r--sound/usb/proc.c168
-rw-r--r--sound/usb/proc.h8
-rw-r--r--sound/usb/quirks-table.h (renamed from sound/usb/usbquirks.h)68
-rw-r--r--sound/usb/quirks.c594
-rw-r--r--sound/usb/quirks.h23
-rw-r--r--sound/usb/urb.c995
-rw-r--r--sound/usb/urb.h21
-rw-r--r--sound/usb/usbaudio.c4050
-rw-r--r--sound/usb/usbaudio.h93
-rw-r--r--sound/usb/usx2y/us122l.c1
-rw-r--r--sound/usb/usx2y/usbusx2y.h1
37 files changed, 5679 insertions, 4757 deletions
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index c570ae3e6d55..44d6d2ec964f 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -22,8 +22,7 @@ config SND_USB_AUDIO
22 will be called snd-usb-audio. 22 will be called snd-usb-audio.
23 23
24config SND_USB_UA101 24config SND_USB_UA101
25 tristate "Edirol UA-101/UA-1000 driver (EXPERIMENTAL)" 25 tristate "Edirol UA-101/UA-1000 driver"
26 depends on EXPERIMENTAL
27 select SND_PCM 26 select SND_PCM
28 select SND_RAWMIDI 27 select SND_RAWMIDI
29 help 28 help
@@ -65,6 +64,7 @@ config SND_USB_CAIAQ
65 * Native Instruments Audio 8 DJ 64 * Native Instruments Audio 8 DJ
66 * Native Instruments Guitar Rig Session I/O 65 * Native Instruments Guitar Rig Session I/O
67 * Native Instruments Guitar Rig mobile 66 * Native Instruments Guitar Rig mobile
67 * Native Instruments Traktor Kontrol X1
68 68
69 To compile this driver as a module, choose M here: the module 69 To compile this driver as a module, choose M here: the module
70 will be called snd-usb-caiaq. 70 will be called snd-usb-caiaq.
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index 5bf64aef9558..e7ac7f493a8f 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -2,14 +2,24 @@
2# Makefile for ALSA 2# Makefile for ALSA
3# 3#
4 4
5snd-usb-audio-objs := usbaudio.o usbmixer.o 5snd-usb-audio-objs := card.o \
6snd-usb-lib-objs := usbmidi.o 6 mixer.o \
7snd-ua101-objs := ua101.o 7 mixer_quirks.o \
8 proc.o \
9 quirks.o \
10 format.o \
11 endpoint.o \
12 urb.o \
13 pcm.o \
14 helper.o
15
16snd-usbmidi-lib-objs := midi.o
8 17
9# Toplevel Module Dependency 18# Toplevel Module Dependency
10obj-$(CONFIG_SND_USB_AUDIO) += snd-usb-audio.o snd-usb-lib.o 19obj-$(CONFIG_SND_USB_AUDIO) += snd-usb-audio.o snd-usbmidi-lib.o
11obj-$(CONFIG_SND_USB_UA101) += snd-ua101.o snd-usb-lib.o 20
12obj-$(CONFIG_SND_USB_USX2Y) += snd-usb-lib.o 21obj-$(CONFIG_SND_USB_UA101) += snd-usbmidi-lib.o
13obj-$(CONFIG_SND_USB_US122L) += snd-usb-lib.o 22obj-$(CONFIG_SND_USB_USX2Y) += snd-usbmidi-lib.o
23obj-$(CONFIG_SND_USB_US122L) += snd-usbmidi-lib.o
14 24
15obj-$(CONFIG_SND) += usx2y/ caiaq/ 25obj-$(CONFIG_SND) += misc/ usx2y/ caiaq/
diff --git a/sound/usb/caiaq/control.c b/sound/usb/caiaq/control.c
index 537102ba6b9d..36ed703a7416 100644
--- a/sound/usb/caiaq/control.c
+++ b/sound/usb/caiaq/control.c
@@ -35,33 +35,41 @@ static int control_info(struct snd_kcontrol *kcontrol,
35 struct snd_usb_caiaqdev *dev = caiaqdev(chip->card); 35 struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
36 int pos = kcontrol->private_value; 36 int pos = kcontrol->private_value;
37 int is_intval = pos & CNT_INTVAL; 37 int is_intval = pos & CNT_INTVAL;
38 unsigned int id = dev->chip.usb_id; 38 int maxval = 63;
39 39
40 uinfo->count = 1; 40 uinfo->count = 1;
41 pos &= ~CNT_INTVAL; 41 pos &= ~CNT_INTVAL;
42 42
43 if (id == USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ) 43 switch (dev->chip.usb_id) {
44 && (pos == 0)) { 44 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
45 /* current input mode of A8DJ */ 45 if (pos == 0) {
46 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 46 /* current input mode of A8DJ */
47 uinfo->value.integer.min = 0; 47 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
48 uinfo->value.integer.max = 2; 48 uinfo->value.integer.min = 0;
49 return 0; 49 uinfo->value.integer.max = 2;
50 } 50 return 0;
51 }
52 break;
51 53
52 if (id == USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ) 54 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
53 && (pos == 0)) { 55 if (pos == 0) {
54 /* current input mode of A4DJ */ 56 /* current input mode of A4DJ */
55 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 57 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
56 uinfo->value.integer.min = 0; 58 uinfo->value.integer.min = 0;
57 uinfo->value.integer.max = 1; 59 uinfo->value.integer.max = 1;
58 return 0; 60 return 0;
61 }
62 break;
63
64 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
65 maxval = 127;
66 break;
59 } 67 }
60 68
61 if (is_intval) { 69 if (is_intval) {
62 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 70 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
63 uinfo->value.integer.min = 0; 71 uinfo->value.integer.min = 0;
64 uinfo->value.integer.max = 64; 72 uinfo->value.integer.max = maxval;
65 } else { 73 } else {
66 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 74 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
67 uinfo->value.integer.min = 0; 75 uinfo->value.integer.min = 0;
@@ -102,9 +110,10 @@ static int control_put(struct snd_kcontrol *kcontrol,
102 struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol); 110 struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol);
103 struct snd_usb_caiaqdev *dev = caiaqdev(chip->card); 111 struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
104 int pos = kcontrol->private_value; 112 int pos = kcontrol->private_value;
113 unsigned char cmd = EP1_CMD_WRITE_IO;
105 114
106 if (dev->chip.usb_id == 115 switch (dev->chip.usb_id) {
107 USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ)) { 116 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ): {
108 /* A4DJ has only one control */ 117 /* A4DJ has only one control */
109 /* do not expose hardware input mode 0 */ 118 /* do not expose hardware input mode 0 */
110 dev->control_state[0] = ucontrol->value.integer.value[0] + 1; 119 dev->control_state[0] = ucontrol->value.integer.value[0] + 1;
@@ -113,10 +122,15 @@ static int control_put(struct snd_kcontrol *kcontrol,
113 return 1; 122 return 1;
114 } 123 }
115 124
125 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
126 cmd = EP1_CMD_DIMM_LEDS;
127 break;
128 }
129
116 if (pos & CNT_INTVAL) { 130 if (pos & CNT_INTVAL) {
117 dev->control_state[pos & ~CNT_INTVAL] 131 dev->control_state[pos & ~CNT_INTVAL]
118 = ucontrol->value.integer.value[0]; 132 = ucontrol->value.integer.value[0];
119 snd_usb_caiaq_send_command(dev, EP1_CMD_WRITE_IO, 133 snd_usb_caiaq_send_command(dev, cmd,
120 dev->control_state, sizeof(dev->control_state)); 134 dev->control_state, sizeof(dev->control_state));
121 } else { 135 } else {
122 if (ucontrol->value.integer.value[0]) 136 if (ucontrol->value.integer.value[0])
@@ -124,7 +138,7 @@ static int control_put(struct snd_kcontrol *kcontrol,
124 else 138 else
125 dev->control_state[pos / 8] &= ~(1 << (pos % 8)); 139 dev->control_state[pos / 8] &= ~(1 << (pos % 8));
126 140
127 snd_usb_caiaq_send_command(dev, EP1_CMD_WRITE_IO, 141 snd_usb_caiaq_send_command(dev, cmd,
128 dev->control_state, sizeof(dev->control_state)); 142 dev->control_state, sizeof(dev->control_state));
129 } 143 }
130 144
@@ -273,6 +287,43 @@ static struct caiaq_controller a4dj_controller[] = {
273 { "Current input mode", 0 | CNT_INTVAL } 287 { "Current input mode", 0 | CNT_INTVAL }
274}; 288};
275 289
290static struct caiaq_controller kontrolx1_controller[] = {
291 { "LED FX A: ON", 7 | CNT_INTVAL },
292 { "LED FX A: 1", 6 | CNT_INTVAL },
293 { "LED FX A: 2", 5 | CNT_INTVAL },
294 { "LED FX A: 3", 4 | CNT_INTVAL },
295 { "LED FX B: ON", 3 | CNT_INTVAL },
296 { "LED FX B: 1", 2 | CNT_INTVAL },
297 { "LED FX B: 2", 1 | CNT_INTVAL },
298 { "LED FX B: 3", 0 | CNT_INTVAL },
299
300 { "LED Hotcue", 28 | CNT_INTVAL },
301 { "LED Shift (white)", 29 | CNT_INTVAL },
302 { "LED Shift (green)", 30 | CNT_INTVAL },
303
304 { "LED Deck A: FX1", 24 | CNT_INTVAL },
305 { "LED Deck A: FX2", 25 | CNT_INTVAL },
306 { "LED Deck A: IN", 17 | CNT_INTVAL },
307 { "LED Deck A: OUT", 16 | CNT_INTVAL },
308 { "LED Deck A: < BEAT", 19 | CNT_INTVAL },
309 { "LED Deck A: BEAT >", 18 | CNT_INTVAL },
310 { "LED Deck A: CUE/ABS", 21 | CNT_INTVAL },
311 { "LED Deck A: CUP/REL", 20 | CNT_INTVAL },
312 { "LED Deck A: PLAY", 23 | CNT_INTVAL },
313 { "LED Deck A: SYNC", 22 | CNT_INTVAL },
314
315 { "LED Deck B: FX1", 26 | CNT_INTVAL },
316 { "LED Deck B: FX2", 27 | CNT_INTVAL },
317 { "LED Deck B: IN", 15 | CNT_INTVAL },
318 { "LED Deck B: OUT", 14 | CNT_INTVAL },
319 { "LED Deck B: < BEAT", 13 | CNT_INTVAL },
320 { "LED Deck B: BEAT >", 12 | CNT_INTVAL },
321 { "LED Deck B: CUE/ABS", 11 | CNT_INTVAL },
322 { "LED Deck B: CUP/REL", 10 | CNT_INTVAL },
323 { "LED Deck B: PLAY", 9 | CNT_INTVAL },
324 { "LED Deck B: SYNC", 8 | CNT_INTVAL },
325};
326
276static int __devinit add_controls(struct caiaq_controller *c, int num, 327static int __devinit add_controls(struct caiaq_controller *c, int num,
277 struct snd_usb_caiaqdev *dev) 328 struct snd_usb_caiaqdev *dev)
278{ 329{
@@ -321,10 +372,16 @@ int __devinit snd_usb_caiaq_control_init(struct snd_usb_caiaqdev *dev)
321 ret = add_controls(a8dj_controller, 372 ret = add_controls(a8dj_controller,
322 ARRAY_SIZE(a8dj_controller), dev); 373 ARRAY_SIZE(a8dj_controller), dev);
323 break; 374 break;
375
324 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ): 376 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
325 ret = add_controls(a4dj_controller, 377 ret = add_controls(a4dj_controller,
326 ARRAY_SIZE(a4dj_controller), dev); 378 ARRAY_SIZE(a4dj_controller), dev);
327 break; 379 break;
380
381 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
382 ret = add_controls(kontrolx1_controller,
383 ARRAY_SIZE(kontrolx1_controller), dev);
384 break;
328 } 385 }
329 386
330 return ret; 387 return ret;
diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c
index afc5aeb68005..805271827675 100644
--- a/sound/usb/caiaq/device.c
+++ b/sound/usb/caiaq/device.c
@@ -47,7 +47,8 @@ MODULE_SUPPORTED_DEVICE("{{Native Instruments, RigKontrol2},"
47 "{Native Instruments, Audio 4 DJ}," 47 "{Native Instruments, Audio 4 DJ},"
48 "{Native Instruments, Audio 8 DJ}," 48 "{Native Instruments, Audio 8 DJ},"
49 "{Native Instruments, Session I/O}," 49 "{Native Instruments, Session I/O},"
50 "{Native Instruments, GuitarRig mobile}"); 50 "{Native Instruments, GuitarRig mobile}"
51 "{Native Instruments, Traktor Kontrol X1}");
51 52
52static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ 53static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */
53static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */ 54static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */
@@ -128,6 +129,11 @@ static struct usb_device_id snd_usb_id_table[] = {
128 .idVendor = USB_VID_NATIVEINSTRUMENTS, 129 .idVendor = USB_VID_NATIVEINSTRUMENTS,
129 .idProduct = USB_PID_AUDIO2DJ 130 .idProduct = USB_PID_AUDIO2DJ
130 }, 131 },
132 {
133 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
134 .idVendor = USB_VID_NATIVEINSTRUMENTS,
135 .idProduct = USB_PID_TRAKTORKONTROLX1
136 },
131 { /* terminator */ } 137 { /* terminator */ }
132}; 138};
133 139
diff --git a/sound/usb/caiaq/device.h b/sound/usb/caiaq/device.h
index 44e3edf88bef..f1117ecc84fd 100644
--- a/sound/usb/caiaq/device.h
+++ b/sound/usb/caiaq/device.h
@@ -5,18 +5,20 @@
5 5
6#define USB_VID_NATIVEINSTRUMENTS 0x17cc 6#define USB_VID_NATIVEINSTRUMENTS 0x17cc
7 7
8#define USB_PID_RIGKONTROL2 0x1969 8#define USB_PID_RIGKONTROL2 0x1969
9#define USB_PID_RIGKONTROL3 0x1940 9#define USB_PID_RIGKONTROL3 0x1940
10#define USB_PID_KORECONTROLLER 0x4711 10#define USB_PID_KORECONTROLLER 0x4711
11#define USB_PID_KORECONTROLLER2 0x4712 11#define USB_PID_KORECONTROLLER2 0x4712
12#define USB_PID_AK1 0x0815 12#define USB_PID_AK1 0x0815
13#define USB_PID_AUDIO2DJ 0x041c 13#define USB_PID_AUDIO2DJ 0x041c
14#define USB_PID_AUDIO4DJ 0x0839 14#define USB_PID_AUDIO4DJ 0x0839
15#define USB_PID_AUDIO8DJ 0x1978 15#define USB_PID_AUDIO8DJ 0x1978
16#define USB_PID_SESSIONIO 0x1915 16#define USB_PID_SESSIONIO 0x1915
17#define USB_PID_GUITARRIGMOBILE 0x0d8d 17#define USB_PID_GUITARRIGMOBILE 0x0d8d
18#define USB_PID_TRAKTORKONTROLX1 0x2305
18 19
19#define EP1_BUFSIZE 64 20#define EP1_BUFSIZE 64
21#define EP4_BUFSIZE 512
20#define CAIAQ_USB_STR_LEN 0xff 22#define CAIAQ_USB_STR_LEN 0xff
21#define MAX_STREAMS 32 23#define MAX_STREAMS 32
22 24
@@ -104,6 +106,8 @@ struct snd_usb_caiaqdev {
104 struct input_dev *input_dev; 106 struct input_dev *input_dev;
105 char phys[64]; /* physical device path */ 107 char phys[64]; /* physical device path */
106 unsigned short keycode[64]; 108 unsigned short keycode[64];
109 struct urb *ep4_in_urb;
110 unsigned char ep4_in_buf[EP4_BUFSIZE];
107#endif 111#endif
108 112
109 /* ALSA */ 113 /* ALSA */
diff --git a/sound/usb/caiaq/input.c b/sound/usb/caiaq/input.c
index a48d309bd94c..8bbfbfd4c658 100644
--- a/sound/usb/caiaq/input.c
+++ b/sound/usb/caiaq/input.c
@@ -16,9 +16,11 @@
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17*/ 17*/
18 18
19#include <linux/gfp.h>
19#include <linux/init.h> 20#include <linux/init.h>
20#include <linux/usb.h> 21#include <linux/usb.h>
21#include <linux/usb/input.h> 22#include <linux/usb/input.h>
23#include <sound/core.h>
22#include <sound/pcm.h> 24#include <sound/pcm.h>
23 25
24#include "device.h" 26#include "device.h"
@@ -65,6 +67,8 @@ static unsigned short keycode_kore[] = {
65 KEY_BRL_DOT5 67 KEY_BRL_DOT5
66}; 68};
67 69
70#define KONTROLX1_INPUTS 40
71
68#define DEG90 (range / 2) 72#define DEG90 (range / 2)
69#define DEG180 (range) 73#define DEG180 (range)
70#define DEG270 (DEG90 + DEG180) 74#define DEG270 (DEG90 + DEG180)
@@ -162,6 +166,17 @@ static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *dev,
162 input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]); 166 input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]);
163 input_sync(input_dev); 167 input_sync(input_dev);
164 break; 168 break;
169 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
170 input_report_abs(input_dev, ABS_HAT0X, (buf[8] << 8) | buf[9]);
171 input_report_abs(input_dev, ABS_HAT0Y, (buf[4] << 8) | buf[5]);
172 input_report_abs(input_dev, ABS_HAT1X, (buf[12] << 8) | buf[13]);
173 input_report_abs(input_dev, ABS_HAT1Y, (buf[2] << 8) | buf[3]);
174 input_report_abs(input_dev, ABS_HAT2X, (buf[15] << 8) | buf[15]);
175 input_report_abs(input_dev, ABS_HAT2Y, (buf[0] << 8) | buf[1]);
176 input_report_abs(input_dev, ABS_HAT3X, (buf[10] << 8) | buf[11]);
177 input_report_abs(input_dev, ABS_HAT3Y, (buf[6] << 8) | buf[7]);
178 input_sync(input_dev);
179 break;
165 } 180 }
166} 181}
167 182
@@ -201,7 +216,7 @@ static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *dev,
201} 216}
202 217
203static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *dev, 218static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *dev,
204 char *buf, unsigned int len) 219 unsigned char *buf, unsigned int len)
205{ 220{
206 struct input_dev *input_dev = dev->input_dev; 221 struct input_dev *input_dev = dev->input_dev;
207 unsigned short *keycode = input_dev->keycode; 222 unsigned short *keycode = input_dev->keycode;
@@ -218,15 +233,84 @@ static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *dev,
218 input_report_key(input_dev, keycode[i], 233 input_report_key(input_dev, keycode[i],
219 buf[i / 8] & (1 << (i % 8))); 234 buf[i / 8] & (1 << (i % 8)));
220 235
221 if (dev->chip.usb_id == 236 switch (dev->chip.usb_id) {
222 USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER) || 237 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
223 dev->chip.usb_id == 238 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
224 USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2))
225 input_report_abs(dev->input_dev, ABS_MISC, 255 - buf[4]); 239 input_report_abs(dev->input_dev, ABS_MISC, 255 - buf[4]);
240 break;
241 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
242 /* rotary encoders */
243 input_report_abs(dev->input_dev, ABS_X, buf[5] & 0xf);
244 input_report_abs(dev->input_dev, ABS_Y, buf[5] >> 4);
245 input_report_abs(dev->input_dev, ABS_Z, buf[6] & 0xf);
246 input_report_abs(dev->input_dev, ABS_MISC, buf[6] >> 4);
247 break;
248 }
226 249
227 input_sync(input_dev); 250 input_sync(input_dev);
228} 251}
229 252
253static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb)
254{
255 struct snd_usb_caiaqdev *dev = urb->context;
256 unsigned char *buf = urb->transfer_buffer;
257 int ret;
258
259 if (urb->status || !dev || urb != dev->ep4_in_urb)
260 return;
261
262 if (urb->actual_length < 24)
263 goto requeue;
264
265 switch (dev->chip.usb_id) {
266 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
267 if (buf[0] & 0x3)
268 snd_caiaq_input_read_io(dev, buf + 1, 7);
269
270 if (buf[0] & 0x4)
271 snd_caiaq_input_read_analog(dev, buf + 8, 16);
272
273 break;
274 }
275
276requeue:
277 dev->ep4_in_urb->actual_length = 0;
278 ret = usb_submit_urb(dev->ep4_in_urb, GFP_ATOMIC);
279 if (ret < 0)
280 log("unable to submit urb. OOM!?\n");
281}
282
283static int snd_usb_caiaq_input_open(struct input_dev *idev)
284{
285 struct snd_usb_caiaqdev *dev = input_get_drvdata(idev);
286
287 if (!dev)
288 return -EINVAL;
289
290 switch (dev->chip.usb_id) {
291 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
292 if (usb_submit_urb(dev->ep4_in_urb, GFP_KERNEL) != 0)
293 return -EIO;
294 break;
295 }
296
297 return 0;
298}
299
300static void snd_usb_caiaq_input_close(struct input_dev *idev)
301{
302 struct snd_usb_caiaqdev *dev = input_get_drvdata(idev);
303
304 if (!dev)
305 return;
306
307 switch (dev->chip.usb_id) {
308 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
309 usb_kill_urb(dev->ep4_in_urb);
310 break;
311 }
312}
313
230void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev *dev, 314void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev *dev,
231 char *buf, 315 char *buf,
232 unsigned int len) 316 unsigned int len)
@@ -251,7 +335,7 @@ int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *dev)
251{ 335{
252 struct usb_device *usb_dev = dev->chip.dev; 336 struct usb_device *usb_dev = dev->chip.dev;
253 struct input_dev *input; 337 struct input_dev *input;
254 int i, ret; 338 int i, ret = 0;
255 339
256 input = input_allocate_device(); 340 input = input_allocate_device();
257 if (!input) 341 if (!input)
@@ -265,7 +349,9 @@ int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *dev)
265 usb_to_input_id(usb_dev, &input->id); 349 usb_to_input_id(usb_dev, &input->id);
266 input->dev.parent = &usb_dev->dev; 350 input->dev.parent = &usb_dev->dev;
267 351
268 switch (dev->chip.usb_id) { 352 input_set_drvdata(input, dev);
353
354 switch (dev->chip.usb_id) {
269 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): 355 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
270 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 356 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
271 input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | 357 input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
@@ -326,25 +412,72 @@ int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *dev)
326 input_set_abs_params(input, ABS_MISC, 0, 255, 0, 1); 412 input_set_abs_params(input, ABS_MISC, 0, 255, 0, 1);
327 snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5); 413 snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5);
328 break; 414 break;
415 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
416 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
417 input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
418 BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
419 BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
420 BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
421 BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
422 BIT_MASK(ABS_Z);
423 input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
424 BUILD_BUG_ON(sizeof(dev->keycode) < KONTROLX1_INPUTS);
425 for (i = 0; i < KONTROLX1_INPUTS; i++)
426 dev->keycode[i] = BTN_MISC + i;
427 input->keycodemax = KONTROLX1_INPUTS;
428
429 /* analog potentiometers */
430 input_set_abs_params(input, ABS_HAT0X, 0, 4096, 0, 10);
431 input_set_abs_params(input, ABS_HAT0Y, 0, 4096, 0, 10);
432 input_set_abs_params(input, ABS_HAT1X, 0, 4096, 0, 10);
433 input_set_abs_params(input, ABS_HAT1Y, 0, 4096, 0, 10);
434 input_set_abs_params(input, ABS_HAT2X, 0, 4096, 0, 10);
435 input_set_abs_params(input, ABS_HAT2Y, 0, 4096, 0, 10);
436 input_set_abs_params(input, ABS_HAT3X, 0, 4096, 0, 10);
437 input_set_abs_params(input, ABS_HAT3Y, 0, 4096, 0, 10);
438
439 /* rotary encoders */
440 input_set_abs_params(input, ABS_X, 0, 0xf, 0, 1);
441 input_set_abs_params(input, ABS_Y, 0, 0xf, 0, 1);
442 input_set_abs_params(input, ABS_Z, 0, 0xf, 0, 1);
443 input_set_abs_params(input, ABS_MISC, 0, 0xf, 0, 1);
444
445 dev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
446 if (!dev->ep4_in_urb) {
447 ret = -ENOMEM;
448 goto exit_free_idev;
449 }
450
451 usb_fill_bulk_urb(dev->ep4_in_urb, usb_dev,
452 usb_rcvbulkpipe(usb_dev, 0x4),
453 dev->ep4_in_buf, EP4_BUFSIZE,
454 snd_usb_caiaq_ep4_reply_dispatch, dev);
455
456 snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5);
457
458 break;
329 default: 459 default:
330 /* no input methods supported on this device */ 460 /* no input methods supported on this device */
331 input_free_device(input); 461 goto exit_free_idev;
332 return 0;
333 } 462 }
334 463
464 input->open = snd_usb_caiaq_input_open;
465 input->close = snd_usb_caiaq_input_close;
335 input->keycode = dev->keycode; 466 input->keycode = dev->keycode;
336 input->keycodesize = sizeof(unsigned short); 467 input->keycodesize = sizeof(unsigned short);
337 for (i = 0; i < input->keycodemax; i++) 468 for (i = 0; i < input->keycodemax; i++)
338 __set_bit(dev->keycode[i], input->keybit); 469 __set_bit(dev->keycode[i], input->keybit);
339 470
340 ret = input_register_device(input); 471 ret = input_register_device(input);
341 if (ret < 0) { 472 if (ret < 0)
342 input_free_device(input); 473 goto exit_free_idev;
343 return ret;
344 }
345 474
346 dev->input_dev = input; 475 dev->input_dev = input;
347 return 0; 476 return 0;
477
478exit_free_idev:
479 input_free_device(input);
480 return ret;
348} 481}
349 482
350void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *dev) 483void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *dev)
@@ -352,6 +485,10 @@ void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *dev)
352 if (!dev || !dev->input_dev) 485 if (!dev || !dev->input_dev)
353 return; 486 return;
354 487
488 usb_kill_urb(dev->ep4_in_urb);
489 usb_free_urb(dev->ep4_in_urb);
490 dev->ep4_in_urb = NULL;
491
355 input_unregister_device(dev->input_dev); 492 input_unregister_device(dev->input_dev);
356 dev->input_dev = NULL; 493 dev->input_dev = NULL;
357} 494}
diff --git a/sound/usb/card.c b/sound/usb/card.c
new file mode 100644
index 000000000000..da1346bd4856
--- /dev/null
+++ b/sound/usb/card.c
@@ -0,0 +1,652 @@
1/*
2 * (Tentative) USB Audio Driver for ALSA
3 *
4 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
5 *
6 * Many codes borrowed from audio.c by
7 * Alan Cox (alan@lxorguk.ukuu.org.uk)
8 * Thomas Sailer (sailer@ife.ee.ethz.ch)
9 *
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 *
26 * NOTES:
27 *
28 * - async unlink should be used for avoiding the sleep inside lock.
29 * 2.4.22 usb-uhci seems buggy for async unlinking and results in
30 * oops. in such a cse, pass async_unlink=0 option.
31 * - the linked URBs would be preferred but not used so far because of
32 * the instability of unlinking.
33 * - type II is not supported properly. there is no device which supports
34 * this type *correctly*. SB extigy looks as if it supports, but it's
35 * indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
36 */
37
38
39#include <linux/bitops.h>
40#include <linux/init.h>
41#include <linux/list.h>
42#include <linux/slab.h>
43#include <linux/string.h>
44#include <linux/usb.h>
45#include <linux/moduleparam.h>
46#include <linux/mutex.h>
47#include <linux/usb/audio.h>
48#include <linux/usb/audio-v2.h>
49
50#include <sound/core.h>
51#include <sound/info.h>
52#include <sound/pcm.h>
53#include <sound/pcm_params.h>
54#include <sound/initval.h>
55
56#include "usbaudio.h"
57#include "card.h"
58#include "midi.h"
59#include "mixer.h"
60#include "proc.h"
61#include "quirks.h"
62#include "endpoint.h"
63#include "helper.h"
64#include "debug.h"
65#include "pcm.h"
66#include "urb.h"
67#include "format.h"
68
69MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
70MODULE_DESCRIPTION("USB Audio");
71MODULE_LICENSE("GPL");
72MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
73
74
75static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
76static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
77static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
78/* Vendor/product IDs for this card */
79static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
80static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
81static int nrpacks = 8; /* max. number of packets per urb */
82static int async_unlink = 1;
83static int device_setup[SNDRV_CARDS]; /* device parameter for this card */
84static int ignore_ctl_error;
85
86module_param_array(index, int, NULL, 0444);
87MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
88module_param_array(id, charp, NULL, 0444);
89MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
90module_param_array(enable, bool, NULL, 0444);
91MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
92module_param_array(vid, int, NULL, 0444);
93MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
94module_param_array(pid, int, NULL, 0444);
95MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
96module_param(nrpacks, int, 0644);
97MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
98module_param(async_unlink, bool, 0444);
99MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
100module_param_array(device_setup, int, NULL, 0444);
101MODULE_PARM_DESC(device_setup, "Specific device setup (if needed).");
102module_param(ignore_ctl_error, bool, 0444);
103MODULE_PARM_DESC(ignore_ctl_error,
104 "Ignore errors from USB controller for mixer interfaces.");
105
106/*
107 * we keep the snd_usb_audio_t instances by ourselves for merging
108 * the all interfaces on the same card as one sound device.
109 */
110
111static DEFINE_MUTEX(register_mutex);
112static struct snd_usb_audio *usb_chip[SNDRV_CARDS];
113static struct usb_driver usb_audio_driver;
114
115/*
116 * disconnect streams
117 * called from snd_usb_audio_disconnect()
118 */
119static void snd_usb_stream_disconnect(struct list_head *head)
120{
121 int idx;
122 struct snd_usb_stream *as;
123 struct snd_usb_substream *subs;
124
125 as = list_entry(head, struct snd_usb_stream, list);
126 for (idx = 0; idx < 2; idx++) {
127 subs = &as->substream[idx];
128 if (!subs->num_formats)
129 return;
130 snd_usb_release_substream_urbs(subs, 1);
131 subs->interface = -1;
132 }
133}
134
135static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface)
136{
137 struct usb_device *dev = chip->dev;
138 struct usb_host_interface *alts;
139 struct usb_interface_descriptor *altsd;
140 struct usb_interface *iface = usb_ifnum_to_if(dev, interface);
141
142 if (!iface) {
143 snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
144 dev->devnum, ctrlif, interface);
145 return -EINVAL;
146 }
147
148 if (usb_interface_claimed(iface)) {
149 snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",
150 dev->devnum, ctrlif, interface);
151 return -EINVAL;
152 }
153
154 alts = &iface->altsetting[0];
155 altsd = get_iface_desc(alts);
156 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
157 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
158 altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) {
159 int err = snd_usbmidi_create(chip->card, iface,
160 &chip->midi_list, NULL);
161 if (err < 0) {
162 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",
163 dev->devnum, ctrlif, interface);
164 return -EINVAL;
165 }
166 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
167
168 return 0;
169 }
170
171 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
172 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
173 altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {
174 snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",
175 dev->devnum, ctrlif, interface, altsd->bInterfaceClass);
176 /* skip non-supported classes */
177 return -EINVAL;
178 }
179
180 if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
181 snd_printk(KERN_ERR "low speed audio streaming not supported\n");
182 return -EINVAL;
183 }
184
185 if (! snd_usb_parse_audio_endpoints(chip, interface)) {
186 usb_set_interface(dev, interface, 0); /* reset the current interface */
187 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
188 return -EINVAL;
189 }
190
191 return 0;
192}
193
194/*
195 * parse audio control descriptor and create pcm/midi streams
196 */
197static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
198{
199 struct usb_device *dev = chip->dev;
200 struct usb_host_interface *host_iface;
201 struct usb_interface_descriptor *altsd;
202 void *control_header;
203 int i, protocol;
204
205 /* find audiocontrol interface */
206 host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
207 control_header = snd_usb_find_csint_desc(host_iface->extra,
208 host_iface->extralen,
209 NULL, UAC_HEADER);
210 altsd = get_iface_desc(host_iface);
211 protocol = altsd->bInterfaceProtocol;
212
213 if (!control_header) {
214 snd_printk(KERN_ERR "cannot find UAC_HEADER\n");
215 return -EINVAL;
216 }
217
218 switch (protocol) {
219 case UAC_VERSION_1: {
220 struct uac_ac_header_descriptor_v1 *h1 = control_header;
221
222 if (!h1->bInCollection) {
223 snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
224 return -EINVAL;
225 }
226
227 if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
228 snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");
229 return -EINVAL;
230 }
231
232 for (i = 0; i < h1->bInCollection; i++)
233 snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]);
234
235 break;
236 }
237
238 case UAC_VERSION_2: {
239 struct uac_clock_source_descriptor *cs;
240 struct usb_interface_assoc_descriptor *assoc =
241 usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
242
243 if (!assoc) {
244 snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");
245 return -EINVAL;
246 }
247
248 /* FIXME: for now, we expect there is at least one clock source
249 * descriptor and we always take the first one.
250 * We should properly support devices with multiple clock sources,
251 * clock selectors and sample rate conversion units. */
252
253 cs = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen,
254 NULL, UAC2_CLOCK_SOURCE);
255
256 if (!cs) {
257 snd_printk(KERN_ERR "CLOCK_SOURCE descriptor not found\n");
258 return -EINVAL;
259 }
260
261 chip->clock_id = cs->bClockID;
262
263 for (i = 0; i < assoc->bInterfaceCount; i++) {
264 int intf = assoc->bFirstInterface + i;
265
266 if (intf != ctrlif)
267 snd_usb_create_stream(chip, ctrlif, intf);
268 }
269
270 break;
271 }
272
273 default:
274 snd_printk(KERN_ERR "unknown protocol version 0x%02x\n", protocol);
275 return -EINVAL;
276 }
277
278 return 0;
279}
280
281/*
282 * free the chip instance
283 *
284 * here we have to do not much, since pcm and controls are already freed
285 *
286 */
287
288static int snd_usb_audio_free(struct snd_usb_audio *chip)
289{
290 kfree(chip);
291 return 0;
292}
293
294static int snd_usb_audio_dev_free(struct snd_device *device)
295{
296 struct snd_usb_audio *chip = device->device_data;
297 return snd_usb_audio_free(chip);
298}
299
300
301/*
302 * create a chip instance and set its names.
303 */
304static int snd_usb_audio_create(struct usb_device *dev, int idx,
305 const struct snd_usb_audio_quirk *quirk,
306 struct snd_usb_audio **rchip)
307{
308 struct snd_card *card;
309 struct snd_usb_audio *chip;
310 int err, len;
311 char component[14];
312 static struct snd_device_ops ops = {
313 .dev_free = snd_usb_audio_dev_free,
314 };
315
316 *rchip = NULL;
317
318 if (snd_usb_get_speed(dev) != USB_SPEED_LOW &&
319 snd_usb_get_speed(dev) != USB_SPEED_FULL &&
320 snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
321 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
322 return -ENXIO;
323 }
324
325 err = snd_card_create(index[idx], id[idx], THIS_MODULE, 0, &card);
326 if (err < 0) {
327 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
328 return err;
329 }
330
331 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
332 if (! chip) {
333 snd_card_free(card);
334 return -ENOMEM;
335 }
336
337 chip->index = idx;
338 chip->dev = dev;
339 chip->card = card;
340 chip->setup = device_setup[idx];
341 chip->nrpacks = nrpacks;
342 chip->async_unlink = async_unlink;
343
344 chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
345 le16_to_cpu(dev->descriptor.idProduct));
346 INIT_LIST_HEAD(&chip->pcm_list);
347 INIT_LIST_HEAD(&chip->midi_list);
348 INIT_LIST_HEAD(&chip->mixer_list);
349
350 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
351 snd_usb_audio_free(chip);
352 snd_card_free(card);
353 return err;
354 }
355
356 strcpy(card->driver, "USB-Audio");
357 sprintf(component, "USB%04x:%04x",
358 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
359 snd_component_add(card, component);
360
361 /* retrieve the device string as shortname */
362 if (quirk && quirk->product_name) {
363 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
364 } else {
365 if (!dev->descriptor.iProduct ||
366 usb_string(dev, dev->descriptor.iProduct,
367 card->shortname, sizeof(card->shortname)) <= 0) {
368 /* no name available from anywhere, so use ID */
369 sprintf(card->shortname, "USB Device %#04x:%#04x",
370 USB_ID_VENDOR(chip->usb_id),
371 USB_ID_PRODUCT(chip->usb_id));
372 }
373 }
374
375 /* retrieve the vendor and device strings as longname */
376 if (quirk && quirk->vendor_name) {
377 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
378 } else {
379 if (dev->descriptor.iManufacturer)
380 len = usb_string(dev, dev->descriptor.iManufacturer,
381 card->longname, sizeof(card->longname));
382 else
383 len = 0;
384 /* we don't really care if there isn't any vendor string */
385 }
386 if (len > 0)
387 strlcat(card->longname, " ", sizeof(card->longname));
388
389 strlcat(card->longname, card->shortname, sizeof(card->longname));
390
391 len = strlcat(card->longname, " at ", sizeof(card->longname));
392
393 if (len < sizeof(card->longname))
394 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
395
396 strlcat(card->longname,
397 snd_usb_get_speed(dev) == USB_SPEED_LOW ? ", low speed" :
398 snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" :
399 ", high speed",
400 sizeof(card->longname));
401
402 snd_usb_audio_create_proc(chip);
403
404 *rchip = chip;
405 return 0;
406}
407
408/*
409 * probe the active usb device
410 *
411 * note that this can be called multiple times per a device, when it
412 * includes multiple audio control interfaces.
413 *
414 * thus we check the usb device pointer and creates the card instance
415 * only at the first time. the successive calls of this function will
416 * append the pcm interface to the corresponding card.
417 */
418static void *snd_usb_audio_probe(struct usb_device *dev,
419 struct usb_interface *intf,
420 const struct usb_device_id *usb_id)
421{
422 const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info;
423 int i, err;
424 struct snd_usb_audio *chip;
425 struct usb_host_interface *alts;
426 int ifnum;
427 u32 id;
428
429 alts = &intf->altsetting[0];
430 ifnum = get_iface_desc(alts)->bInterfaceNumber;
431 id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
432 le16_to_cpu(dev->descriptor.idProduct));
433 if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
434 goto __err_val;
435
436 if (snd_usb_apply_boot_quirk(dev, intf, quirk) < 0)
437 goto __err_val;
438
439 /*
440 * found a config. now register to ALSA
441 */
442
443 /* check whether it's already registered */
444 chip = NULL;
445 mutex_lock(&register_mutex);
446 for (i = 0; i < SNDRV_CARDS; i++) {
447 if (usb_chip[i] && usb_chip[i]->dev == dev) {
448 if (usb_chip[i]->shutdown) {
449 snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
450 goto __error;
451 }
452 chip = usb_chip[i];
453 break;
454 }
455 }
456 if (! chip) {
457 /* it's a fresh one.
458 * now look for an empty slot and create a new card instance
459 */
460 for (i = 0; i < SNDRV_CARDS; i++)
461 if (enable[i] && ! usb_chip[i] &&
462 (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
463 (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
464 if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
465 goto __error;
466 }
467 snd_card_set_dev(chip->card, &intf->dev);
468 break;
469 }
470 if (!chip) {
471 printk(KERN_ERR "no available usb audio device\n");
472 goto __error;
473 }
474 }
475
476 chip->txfr_quirk = 0;
477 err = 1; /* continue */
478 if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
479 /* need some special handlings */
480 if ((err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk)) < 0)
481 goto __error;
482 }
483
484 if (err > 0) {
485 /* create normal USB audio interfaces */
486 if (snd_usb_create_streams(chip, ifnum) < 0 ||
487 snd_usb_create_mixer(chip, ifnum, ignore_ctl_error) < 0) {
488 goto __error;
489 }
490 }
491
492 /* we are allowed to call snd_card_register() many times */
493 if (snd_card_register(chip->card) < 0) {
494 goto __error;
495 }
496
497 usb_chip[chip->index] = chip;
498 chip->num_interfaces++;
499 mutex_unlock(&register_mutex);
500 return chip;
501
502 __error:
503 if (chip && !chip->num_interfaces)
504 snd_card_free(chip->card);
505 mutex_unlock(&register_mutex);
506 __err_val:
507 return NULL;
508}
509
510/*
511 * we need to take care of counter, since disconnection can be called also
512 * many times as well as usb_audio_probe().
513 */
514static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
515{
516 struct snd_usb_audio *chip;
517 struct snd_card *card;
518 struct list_head *p;
519
520 if (ptr == (void *)-1L)
521 return;
522
523 chip = ptr;
524 card = chip->card;
525 mutex_lock(&register_mutex);
526 chip->shutdown = 1;
527 chip->num_interfaces--;
528 if (chip->num_interfaces <= 0) {
529 snd_card_disconnect(card);
530 /* release the pcm resources */
531 list_for_each(p, &chip->pcm_list) {
532 snd_usb_stream_disconnect(p);
533 }
534 /* release the midi resources */
535 list_for_each(p, &chip->midi_list) {
536 snd_usbmidi_disconnect(p);
537 }
538 /* release mixer resources */
539 list_for_each(p, &chip->mixer_list) {
540 snd_usb_mixer_disconnect(p);
541 }
542 usb_chip[chip->index] = NULL;
543 mutex_unlock(&register_mutex);
544 snd_card_free_when_closed(card);
545 } else {
546 mutex_unlock(&register_mutex);
547 }
548}
549
550/*
551 * new 2.5 USB kernel API
552 */
553static int usb_audio_probe(struct usb_interface *intf,
554 const struct usb_device_id *id)
555{
556 void *chip;
557 chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
558 if (chip) {
559 usb_set_intfdata(intf, chip);
560 return 0;
561 } else
562 return -EIO;
563}
564
565static void usb_audio_disconnect(struct usb_interface *intf)
566{
567 snd_usb_audio_disconnect(interface_to_usbdev(intf),
568 usb_get_intfdata(intf));
569}
570
571#ifdef CONFIG_PM
572static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
573{
574 struct snd_usb_audio *chip = usb_get_intfdata(intf);
575 struct list_head *p;
576 struct snd_usb_stream *as;
577
578 if (chip == (void *)-1L)
579 return 0;
580
581 snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
582 if (!chip->num_suspended_intf++) {
583 list_for_each(p, &chip->pcm_list) {
584 as = list_entry(p, struct snd_usb_stream, list);
585 snd_pcm_suspend_all(as->pcm);
586 }
587 }
588
589 return 0;
590}
591
592static int usb_audio_resume(struct usb_interface *intf)
593{
594 struct snd_usb_audio *chip = usb_get_intfdata(intf);
595
596 if (chip == (void *)-1L)
597 return 0;
598 if (--chip->num_suspended_intf)
599 return 0;
600 /*
601 * ALSA leaves material resumption to user space
602 * we just notify
603 */
604
605 snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
606
607 return 0;
608}
609#else
610#define usb_audio_suspend NULL
611#define usb_audio_resume NULL
612#endif /* CONFIG_PM */
613
614static struct usb_device_id usb_audio_ids [] = {
615#include "quirks-table.h"
616 { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
617 .bInterfaceClass = USB_CLASS_AUDIO,
618 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL },
619 { } /* Terminating entry */
620};
621
622MODULE_DEVICE_TABLE (usb, usb_audio_ids);
623
624/*
625 * entry point for linux usb interface
626 */
627
628static struct usb_driver usb_audio_driver = {
629 .name = "snd-usb-audio",
630 .probe = usb_audio_probe,
631 .disconnect = usb_audio_disconnect,
632 .suspend = usb_audio_suspend,
633 .resume = usb_audio_resume,
634 .id_table = usb_audio_ids,
635};
636
637static int __init snd_usb_audio_init(void)
638{
639 if (nrpacks < 1 || nrpacks > MAX_PACKS) {
640 printk(KERN_WARNING "invalid nrpacks value.\n");
641 return -EINVAL;
642 }
643 return usb_register(&usb_audio_driver);
644}
645
646static void __exit snd_usb_audio_cleanup(void)
647{
648 usb_deregister(&usb_audio_driver);
649}
650
651module_init(snd_usb_audio_init);
652module_exit(snd_usb_audio_cleanup);
diff --git a/sound/usb/card.h b/sound/usb/card.h
new file mode 100644
index 000000000000..ed92420c1095
--- /dev/null
+++ b/sound/usb/card.h
@@ -0,0 +1,105 @@
1#ifndef __USBAUDIO_CARD_H
2#define __USBAUDIO_CARD_H
3
4#define MAX_PACKS 20
5#define MAX_PACKS_HS (MAX_PACKS * 8) /* in high speed mode */
6#define MAX_URBS 8
7#define SYNC_URBS 4 /* always four urbs for sync */
8#define MAX_QUEUE 24 /* try not to exceed this queue length, in ms */
9
10struct audioformat {
11 struct list_head list;
12 u64 formats; /* ALSA format bits */
13 unsigned int channels; /* # channels */
14 unsigned int fmt_type; /* USB audio format type (1-3) */
15 unsigned int frame_size; /* samples per frame for non-audio */
16 int iface; /* interface number */
17 unsigned char altsetting; /* corresponding alternate setting */
18 unsigned char altset_idx; /* array index of altenate setting */
19 unsigned char attributes; /* corresponding attributes of cs endpoint */
20 unsigned char endpoint; /* endpoint */
21 unsigned char ep_attr; /* endpoint attributes */
22 unsigned char datainterval; /* log_2 of data packet interval */
23 unsigned int maxpacksize; /* max. packet size */
24 unsigned int rates; /* rate bitmasks */
25 unsigned int rate_min, rate_max; /* min/max rates */
26 unsigned int nr_rates; /* number of rate table entries */
27 unsigned int *rate_table; /* rate table */
28};
29
30struct snd_usb_substream;
31
32struct snd_urb_ctx {
33 struct urb *urb;
34 unsigned int buffer_size; /* size of data buffer, if data URB */
35 struct snd_usb_substream *subs;
36 int index; /* index for urb array */
37 int packets; /* number of packets per urb */
38};
39
40struct snd_urb_ops {
41 int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
42 int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
43 int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
44 int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
45};
46
47struct snd_usb_substream {
48 struct snd_usb_stream *stream;
49 struct usb_device *dev;
50 struct snd_pcm_substream *pcm_substream;
51 int direction; /* playback or capture */
52 int interface; /* current interface */
53 int endpoint; /* assigned endpoint */
54 struct audioformat *cur_audiofmt; /* current audioformat pointer (for hw_params callback) */
55 unsigned int cur_rate; /* current rate (for hw_params callback) */
56 unsigned int period_bytes; /* current period bytes (for hw_params callback) */
57 unsigned int altset_idx; /* USB data format: index of alternate setting */
58 unsigned int datapipe; /* the data i/o pipe */
59 unsigned int syncpipe; /* 1 - async out or adaptive in */
60 unsigned int datainterval; /* log_2 of data packet interval */
61 unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */
62 unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */
63 unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */
64 unsigned int freqmax; /* maximum sampling rate, used for buffer management */
65 unsigned int phase; /* phase accumulator */
66 unsigned int maxpacksize; /* max packet size in bytes */
67 unsigned int maxframesize; /* max packet size in frames */
68 unsigned int curpacksize; /* current packet size in bytes (for capture) */
69 unsigned int curframesize; /* current packet size in frames (for capture) */
70 unsigned int fill_max: 1; /* fill max packet size always */
71 unsigned int txfr_quirk:1; /* allow sub-frame alignment */
72 unsigned int fmt_type; /* USB audio format type (1-3) */
73
74 unsigned int running: 1; /* running status */
75
76 unsigned int hwptr_done; /* processed byte position in the buffer */
77 unsigned int transfer_done; /* processed frames since last period update */
78 unsigned long active_mask; /* bitmask of active urbs */
79 unsigned long unlink_mask; /* bitmask of unlinked urbs */
80
81 unsigned int nurbs; /* # urbs */
82 struct snd_urb_ctx dataurb[MAX_URBS]; /* data urb table */
83 struct snd_urb_ctx syncurb[SYNC_URBS]; /* sync urb table */
84 char *syncbuf; /* sync buffer for all sync URBs */
85 dma_addr_t sync_dma; /* DMA address of syncbuf */
86
87 u64 formats; /* format bitmasks (all or'ed) */
88 unsigned int num_formats; /* number of supported audio formats (list) */
89 struct list_head fmt_list; /* format list */
90 struct snd_pcm_hw_constraint_list rate_list; /* limited rates */
91 spinlock_t lock;
92
93 struct snd_urb_ops ops; /* callbacks (must be filled at init) */
94};
95
96struct snd_usb_stream {
97 struct snd_usb_audio *chip;
98 struct snd_pcm *pcm;
99 int pcm_index;
100 unsigned int fmt_type; /* USB audio format type (1-3) */
101 struct snd_usb_substream substream[2];
102 struct list_head list;
103};
104
105#endif /* __USBAUDIO_CARD_H */
diff --git a/sound/usb/debug.h b/sound/usb/debug.h
new file mode 100644
index 000000000000..343ec2d9ee66
--- /dev/null
+++ b/sound/usb/debug.h
@@ -0,0 +1,15 @@
1#ifndef __USBAUDIO_DEBUG_H
2#define __USBAUDIO_DEBUG_H
3
4/*
5 * h/w constraints
6 */
7
8#ifdef HW_CONST_DEBUG
9#define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
10#else
11#define hwc_debug(fmt, args...) /**/
12#endif
13
14#endif /* __USBAUDIO_DEBUG_H */
15
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
new file mode 100644
index 000000000000..ef07a6d0dd5f
--- /dev/null
+++ b/sound/usb/endpoint.c
@@ -0,0 +1,362 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 */
17
18#include <linux/init.h>
19#include <linux/slab.h>
20#include <linux/usb.h>
21#include <linux/usb/audio.h>
22#include <linux/usb/audio-v2.h>
23
24#include <sound/core.h>
25#include <sound/pcm.h>
26
27#include "usbaudio.h"
28#include "card.h"
29#include "proc.h"
30#include "quirks.h"
31#include "endpoint.h"
32#include "urb.h"
33#include "pcm.h"
34#include "helper.h"
35#include "format.h"
36
37/*
38 * free a substream
39 */
40static void free_substream(struct snd_usb_substream *subs)
41{
42 struct list_head *p, *n;
43
44 if (!subs->num_formats)
45 return; /* not initialized */
46 list_for_each_safe(p, n, &subs->fmt_list) {
47 struct audioformat *fp = list_entry(p, struct audioformat, list);
48 kfree(fp->rate_table);
49 kfree(fp);
50 }
51 kfree(subs->rate_list.list);
52}
53
54
55/*
56 * free a usb stream instance
57 */
58static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
59{
60 free_substream(&stream->substream[0]);
61 free_substream(&stream->substream[1]);
62 list_del(&stream->list);
63 kfree(stream);
64}
65
66static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
67{
68 struct snd_usb_stream *stream = pcm->private_data;
69 if (stream) {
70 stream->pcm = NULL;
71 snd_usb_audio_stream_free(stream);
72 }
73}
74
75
76/*
77 * add this endpoint to the chip instance.
78 * if a stream with the same endpoint already exists, append to it.
79 * if not, create a new pcm stream.
80 */
81int snd_usb_add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp)
82{
83 struct list_head *p;
84 struct snd_usb_stream *as;
85 struct snd_usb_substream *subs;
86 struct snd_pcm *pcm;
87 int err;
88
89 list_for_each(p, &chip->pcm_list) {
90 as = list_entry(p, struct snd_usb_stream, list);
91 if (as->fmt_type != fp->fmt_type)
92 continue;
93 subs = &as->substream[stream];
94 if (!subs->endpoint)
95 continue;
96 if (subs->endpoint == fp->endpoint) {
97 list_add_tail(&fp->list, &subs->fmt_list);
98 subs->num_formats++;
99 subs->formats |= fp->formats;
100 return 0;
101 }
102 }
103 /* look for an empty stream */
104 list_for_each(p, &chip->pcm_list) {
105 as = list_entry(p, struct snd_usb_stream, list);
106 if (as->fmt_type != fp->fmt_type)
107 continue;
108 subs = &as->substream[stream];
109 if (subs->endpoint)
110 continue;
111 err = snd_pcm_new_stream(as->pcm, stream, 1);
112 if (err < 0)
113 return err;
114 snd_usb_init_substream(as, stream, fp);
115 return 0;
116 }
117
118 /* create a new pcm */
119 as = kzalloc(sizeof(*as), GFP_KERNEL);
120 if (!as)
121 return -ENOMEM;
122 as->pcm_index = chip->pcm_devs;
123 as->chip = chip;
124 as->fmt_type = fp->fmt_type;
125 err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
126 stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
127 stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
128 &pcm);
129 if (err < 0) {
130 kfree(as);
131 return err;
132 }
133 as->pcm = pcm;
134 pcm->private_data = as;
135 pcm->private_free = snd_usb_audio_pcm_free;
136 pcm->info_flags = 0;
137 if (chip->pcm_devs > 0)
138 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
139 else
140 strcpy(pcm->name, "USB Audio");
141
142 snd_usb_init_substream(as, stream, fp);
143
144 list_add(&as->list, &chip->pcm_list);
145 chip->pcm_devs++;
146
147 snd_usb_proc_pcm_format_add(as);
148
149 return 0;
150}
151
152int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
153{
154 struct usb_device *dev;
155 struct usb_interface *iface;
156 struct usb_host_interface *alts;
157 struct usb_interface_descriptor *altsd;
158 int i, altno, err, stream;
159 int format = 0, num_channels = 0;
160 struct audioformat *fp = NULL;
161 unsigned char *fmt, *csep;
162 int num, protocol;
163
164 dev = chip->dev;
165
166 /* parse the interface's altsettings */
167 iface = usb_ifnum_to_if(dev, iface_no);
168
169 num = iface->num_altsetting;
170
171 /*
172 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
173 * one misses syncpipe, and does not produce any sound.
174 */
175 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
176 num = 4;
177
178 for (i = 0; i < num; i++) {
179 alts = &iface->altsetting[i];
180 altsd = get_iface_desc(alts);
181 protocol = altsd->bInterfaceProtocol;
182 /* skip invalid one */
183 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
184 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
185 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
186 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
187 altsd->bNumEndpoints < 1 ||
188 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
189 continue;
190 /* must be isochronous */
191 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
192 USB_ENDPOINT_XFER_ISOC)
193 continue;
194 /* check direction */
195 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
196 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
197 altno = altsd->bAlternateSetting;
198
199 if (snd_usb_apply_interface_quirk(chip, iface_no, altno))
200 continue;
201
202 /* get audio formats */
203 switch (protocol) {
204 case UAC_VERSION_1: {
205 struct uac_as_header_descriptor_v1 *as =
206 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
207
208 if (!as) {
209 snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
210 dev->devnum, iface_no, altno);
211 continue;
212 }
213
214 if (as->bLength < sizeof(*as)) {
215 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
216 dev->devnum, iface_no, altno);
217 continue;
218 }
219
220 format = le16_to_cpu(as->wFormatTag); /* remember the format value */
221 break;
222 }
223
224 case UAC_VERSION_2: {
225 struct uac_as_header_descriptor_v2 *as =
226 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
227
228 if (!as) {
229 snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
230 dev->devnum, iface_no, altno);
231 continue;
232 }
233
234 if (as->bLength < sizeof(*as)) {
235 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
236 dev->devnum, iface_no, altno);
237 continue;
238 }
239
240 num_channels = as->bNrChannels;
241 format = le32_to_cpu(as->bmFormats);
242
243 break;
244 }
245
246 default:
247 snd_printk(KERN_ERR "%d:%u:%d : unknown interface protocol %04x\n",
248 dev->devnum, iface_no, altno, protocol);
249 continue;
250 }
251
252 /* get format type */
253 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
254 if (!fmt) {
255 snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n",
256 dev->devnum, iface_no, altno);
257 continue;
258 }
259 if (((protocol == UAC_VERSION_1) && (fmt[0] < 8)) ||
260 ((protocol == UAC_VERSION_2) && (fmt[0] != 6))) {
261 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
262 dev->devnum, iface_no, altno);
263 continue;
264 }
265
266 /*
267 * Blue Microphones workaround: The last altsetting is identical
268 * with the previous one, except for a larger packet size, but
269 * is actually a mislabeled two-channel setting; ignore it.
270 */
271 if (fmt[4] == 1 && fmt[5] == 2 && altno == 2 && num == 3 &&
272 fp && fp->altsetting == 1 && fp->channels == 1 &&
273 fp->formats == SNDRV_PCM_FMTBIT_S16_LE &&
274 protocol == UAC_VERSION_1 &&
275 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
276 fp->maxpacksize * 2)
277 continue;
278
279 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
280 /* Creamware Noah has this descriptor after the 2nd endpoint */
281 if (!csep && altsd->bNumEndpoints >= 2)
282 csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
283 if (!csep || csep[0] < 7 || csep[2] != UAC_EP_GENERAL) {
284 snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
285 " class specific endpoint descriptor\n",
286 dev->devnum, iface_no, altno);
287 csep = NULL;
288 }
289
290 fp = kzalloc(sizeof(*fp), GFP_KERNEL);
291 if (! fp) {
292 snd_printk(KERN_ERR "cannot malloc\n");
293 return -ENOMEM;
294 }
295
296 fp->iface = iface_no;
297 fp->altsetting = altno;
298 fp->altset_idx = i;
299 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
300 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
301 fp->datainterval = snd_usb_parse_datainterval(chip, alts);
302 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
303 /* num_channels is only set for v2 interfaces */
304 fp->channels = num_channels;
305 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
306 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
307 * (fp->maxpacksize & 0x7ff);
308 fp->attributes = csep ? csep[3] : 0;
309
310 /* some quirks for attributes here */
311
312 switch (chip->usb_id) {
313 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
314 /* Optoplay sets the sample rate attribute although
315 * it seems not supporting it in fact.
316 */
317 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
318 break;
319 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
320 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
321 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */
322 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
323 /* doesn't set the sample rate attribute, but supports it */
324 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
325 break;
326 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
327 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
328 an older model 77d:223) */
329 /*
330 * plantronics headset and Griffin iMic have set adaptive-in
331 * although it's really not...
332 */
333 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
334 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
335 fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
336 else
337 fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
338 break;
339 }
340
341 /* ok, let's parse further... */
342 if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) {
343 kfree(fp->rate_table);
344 kfree(fp);
345 continue;
346 }
347
348 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint %#x\n", dev->devnum, iface_no, altno, fp->endpoint);
349 err = snd_usb_add_audio_endpoint(chip, stream, fp);
350 if (err < 0) {
351 kfree(fp->rate_table);
352 kfree(fp);
353 return err;
354 }
355 /* try to set the interface... */
356 usb_set_interface(chip->dev, iface_no, altno);
357 snd_usb_init_pitch(chip, iface_no, alts, fp);
358 snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max);
359 }
360 return 0;
361}
362
diff --git a/sound/usb/endpoint.h b/sound/usb/endpoint.h
new file mode 100644
index 000000000000..64dd0db023b2
--- /dev/null
+++ b/sound/usb/endpoint.h
@@ -0,0 +1,11 @@
1#ifndef __USBAUDIO_ENDPOINT_H
2#define __USBAUDIO_ENDPOINT_H
3
4int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip,
5 int iface_no);
6
7int snd_usb_add_audio_endpoint(struct snd_usb_audio *chip,
8 int stream,
9 struct audioformat *fp);
10
11#endif /* __USBAUDIO_ENDPOINT_H */
diff --git a/sound/usb/format.c b/sound/usb/format.c
new file mode 100644
index 000000000000..b87cf87c4e7b
--- /dev/null
+++ b/sound/usb/format.c
@@ -0,0 +1,432 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 */
17
18#include <linux/init.h>
19#include <linux/slab.h>
20#include <linux/usb.h>
21#include <linux/usb/audio.h>
22#include <linux/usb/audio-v2.h>
23
24#include <sound/core.h>
25#include <sound/pcm.h>
26
27#include "usbaudio.h"
28#include "card.h"
29#include "quirks.h"
30#include "helper.h"
31#include "debug.h"
32
33/*
34 * parse the audio format type I descriptor
35 * and returns the corresponding pcm format
36 *
37 * @dev: usb device
38 * @fp: audioformat record
39 * @format: the format tag (wFormatTag)
40 * @fmt: the format type descriptor
41 */
42static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
43 struct audioformat *fp,
44 int format, void *_fmt,
45 int protocol)
46{
47 int sample_width, sample_bytes;
48 u64 pcm_formats;
49
50 switch (protocol) {
51 case UAC_VERSION_1: {
52 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
53 sample_width = fmt->bBitResolution;
54 sample_bytes = fmt->bSubframeSize;
55 format = 1 << format;
56 break;
57 }
58
59 case UAC_VERSION_2: {
60 struct uac_format_type_i_ext_descriptor *fmt = _fmt;
61 sample_width = fmt->bBitResolution;
62 sample_bytes = fmt->bSubslotSize;
63 format <<= 1;
64 break;
65 }
66
67 default:
68 return -EINVAL;
69 }
70
71 pcm_formats = 0;
72
73 if (format == 0 || format == (1 << UAC_FORMAT_TYPE_I_UNDEFINED)) {
74 /* some devices don't define this correctly... */
75 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
76 chip->dev->devnum, fp->iface, fp->altsetting);
77 format = 1 << UAC_FORMAT_TYPE_I_PCM;
78 }
79 if (format & (1 << UAC_FORMAT_TYPE_I_PCM)) {
80 if (sample_width > sample_bytes * 8) {
81 snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
82 chip->dev->devnum, fp->iface, fp->altsetting,
83 sample_width, sample_bytes);
84 }
85 /* check the format byte size */
86 switch (sample_bytes) {
87 case 1:
88 pcm_formats |= SNDRV_PCM_FMTBIT_S8;
89 break;
90 case 2:
91 if (snd_usb_is_big_endian_format(chip, fp))
92 pcm_formats |= SNDRV_PCM_FMTBIT_S16_BE; /* grrr, big endian!! */
93 else
94 pcm_formats |= SNDRV_PCM_FMTBIT_S16_LE;
95 break;
96 case 3:
97 if (snd_usb_is_big_endian_format(chip, fp))
98 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3BE; /* grrr, big endian!! */
99 else
100 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3LE;
101 break;
102 case 4:
103 pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE;
104 break;
105 default:
106 snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
107 chip->dev->devnum, fp->iface, fp->altsetting,
108 sample_width, sample_bytes);
109 break;
110 }
111 }
112 if (format & (1 << UAC_FORMAT_TYPE_I_PCM8)) {
113 /* Dallas DS4201 workaround: it advertises U8 format, but really
114 supports S8. */
115 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
116 pcm_formats |= SNDRV_PCM_FMTBIT_S8;
117 else
118 pcm_formats |= SNDRV_PCM_FMTBIT_U8;
119 }
120 if (format & (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT)) {
121 pcm_formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
122 }
123 if (format & (1 << UAC_FORMAT_TYPE_I_ALAW)) {
124 pcm_formats |= SNDRV_PCM_FMTBIT_A_LAW;
125 }
126 if (format & (1 << UAC_FORMAT_TYPE_I_MULAW)) {
127 pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW;
128 }
129 if (format & ~0x3f) {
130 snd_printk(KERN_INFO "%d:%u:%d : unsupported format bits %#x\n",
131 chip->dev->devnum, fp->iface, fp->altsetting, format);
132 }
133 return pcm_formats;
134}
135
136
137/*
138 * parse the format descriptor and stores the possible sample rates
139 * on the audioformat table (audio class v1).
140 *
141 * @dev: usb device
142 * @fp: audioformat record
143 * @fmt: the format descriptor
144 * @offset: the start offset of descriptor pointing the rate type
145 * (7 for type I and II, 8 for type II)
146 */
147static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp,
148 unsigned char *fmt, int offset)
149{
150 int nr_rates = fmt[offset];
151
152 if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
153 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
154 chip->dev->devnum, fp->iface, fp->altsetting);
155 return -1;
156 }
157
158 if (nr_rates) {
159 /*
160 * build the rate table and bitmap flags
161 */
162 int r, idx;
163
164 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
165 if (fp->rate_table == NULL) {
166 snd_printk(KERN_ERR "cannot malloc\n");
167 return -1;
168 }
169
170 fp->nr_rates = 0;
171 fp->rate_min = fp->rate_max = 0;
172 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
173 unsigned int rate = combine_triple(&fmt[idx]);
174 if (!rate)
175 continue;
176 /* C-Media CM6501 mislabels its 96 kHz altsetting */
177 if (rate == 48000 && nr_rates == 1 &&
178 (chip->usb_id == USB_ID(0x0d8c, 0x0201) ||
179 chip->usb_id == USB_ID(0x0d8c, 0x0102)) &&
180 fp->altsetting == 5 && fp->maxpacksize == 392)
181 rate = 96000;
182 /* Creative VF0470 Live Cam reports 16 kHz instead of 8kHz */
183 if (rate == 16000 && chip->usb_id == USB_ID(0x041e, 0x4068))
184 rate = 8000;
185
186 fp->rate_table[fp->nr_rates] = rate;
187 if (!fp->rate_min || rate < fp->rate_min)
188 fp->rate_min = rate;
189 if (!fp->rate_max || rate > fp->rate_max)
190 fp->rate_max = rate;
191 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
192 fp->nr_rates++;
193 }
194 if (!fp->nr_rates) {
195 hwc_debug("All rates were zero. Skipping format!\n");
196 return -1;
197 }
198 } else {
199 /* continuous rates */
200 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
201 fp->rate_min = combine_triple(&fmt[offset + 1]);
202 fp->rate_max = combine_triple(&fmt[offset + 4]);
203 }
204 return 0;
205}
206
207/*
208 * parse the format descriptor and stores the possible sample rates
209 * on the audioformat table (audio class v2).
210 */
211static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
212 struct audioformat *fp,
213 struct usb_host_interface *iface)
214{
215 struct usb_device *dev = chip->dev;
216 unsigned char tmp[2], *data;
217 int i, nr_rates, data_size, ret = 0;
218
219 /* get the number of sample rates first by only fetching 2 bytes */
220 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
221 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
222 UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
223 tmp, sizeof(tmp), 1000);
224
225 if (ret < 0) {
226 snd_printk(KERN_ERR "unable to retrieve number of sample rates\n");
227 goto err;
228 }
229
230 nr_rates = (tmp[1] << 8) | tmp[0];
231 data_size = 2 + 12 * nr_rates;
232 data = kzalloc(data_size, GFP_KERNEL);
233 if (!data) {
234 ret = -ENOMEM;
235 goto err;
236 }
237
238 /* now get the full information */
239 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
240 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
241 UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
242 data, data_size, 1000);
243
244 if (ret < 0) {
245 snd_printk(KERN_ERR "unable to retrieve sample rate range\n");
246 ret = -EINVAL;
247 goto err_free;
248 }
249
250 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
251 if (!fp->rate_table) {
252 ret = -ENOMEM;
253 goto err_free;
254 }
255
256 fp->nr_rates = 0;
257 fp->rate_min = fp->rate_max = 0;
258
259 for (i = 0; i < nr_rates; i++) {
260 int rate = combine_quad(&data[2 + 12 * i]);
261
262 fp->rate_table[fp->nr_rates] = rate;
263 if (!fp->rate_min || rate < fp->rate_min)
264 fp->rate_min = rate;
265 if (!fp->rate_max || rate > fp->rate_max)
266 fp->rate_max = rate;
267 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
268 fp->nr_rates++;
269 }
270
271err_free:
272 kfree(data);
273err:
274 return ret;
275}
276
277/*
278 * parse the format type I and III descriptors
279 */
280static int parse_audio_format_i(struct snd_usb_audio *chip,
281 struct audioformat *fp,
282 int format, void *_fmt,
283 struct usb_host_interface *iface)
284{
285 struct usb_interface_descriptor *altsd = get_iface_desc(iface);
286 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
287 int protocol = altsd->bInterfaceProtocol;
288 int pcm_format, ret;
289
290 if (fmt->bFormatType == UAC_FORMAT_TYPE_III) {
291 /* FIXME: the format type is really IECxxx
292 * but we give normal PCM format to get the existing
293 * apps working...
294 */
295 switch (chip->usb_id) {
296
297 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
298 if (chip->setup == 0x00 &&
299 fp->altsetting == 6)
300 pcm_format = SNDRV_PCM_FORMAT_S16_BE;
301 else
302 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
303 break;
304 default:
305 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
306 }
307 fp->formats = 1uLL << pcm_format;
308 } else {
309 fp->formats = parse_audio_format_i_type(chip, fp, format,
310 fmt, protocol);
311 if (!fp->formats)
312 return -1;
313 }
314
315 /* gather possible sample rates */
316 /* audio class v1 reports possible sample rates as part of the
317 * proprietary class specific descriptor.
318 * audio class v2 uses class specific EP0 range requests for that.
319 */
320 switch (protocol) {
321 case UAC_VERSION_1:
322 fp->channels = fmt->bNrChannels;
323 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 7);
324 break;
325 case UAC_VERSION_2:
326 /* fp->channels is already set in this case */
327 ret = parse_audio_format_rates_v2(chip, fp, iface);
328 break;
329 }
330
331 if (fp->channels < 1) {
332 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
333 chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
334 return -1;
335 }
336
337 return ret;
338}
339
340/*
341 * parse the format type II descriptor
342 */
343static int parse_audio_format_ii(struct snd_usb_audio *chip,
344 struct audioformat *fp,
345 int format, void *_fmt,
346 struct usb_host_interface *iface)
347{
348 int brate, framesize, ret;
349 struct usb_interface_descriptor *altsd = get_iface_desc(iface);
350 int protocol = altsd->bInterfaceProtocol;
351
352 switch (format) {
353 case UAC_FORMAT_TYPE_II_AC3:
354 /* FIXME: there is no AC3 format defined yet */
355 // fp->formats = SNDRV_PCM_FMTBIT_AC3;
356 fp->formats = SNDRV_PCM_FMTBIT_U8; /* temporary hack to receive byte streams */
357 break;
358 case UAC_FORMAT_TYPE_II_MPEG:
359 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
360 break;
361 default:
362 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected. processed as MPEG.\n",
363 chip->dev->devnum, fp->iface, fp->altsetting, format);
364 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
365 break;
366 }
367
368 fp->channels = 1;
369
370 switch (protocol) {
371 case UAC_VERSION_1: {
372 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
373 brate = le16_to_cpu(fmt->wMaxBitRate);
374 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
375 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
376 fp->frame_size = framesize;
377 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
378 break;
379 }
380 case UAC_VERSION_2: {
381 struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
382 brate = le16_to_cpu(fmt->wMaxBitRate);
383 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
384 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
385 fp->frame_size = framesize;
386 ret = parse_audio_format_rates_v2(chip, fp, iface);
387 break;
388 }
389 }
390
391 return ret;
392}
393
394int snd_usb_parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
395 int format, unsigned char *fmt, int stream,
396 struct usb_host_interface *iface)
397{
398 int err;
399
400 switch (fmt[3]) {
401 case UAC_FORMAT_TYPE_I:
402 case UAC_FORMAT_TYPE_III:
403 err = parse_audio_format_i(chip, fp, format, fmt, iface);
404 break;
405 case UAC_FORMAT_TYPE_II:
406 err = parse_audio_format_ii(chip, fp, format, fmt, iface);
407 break;
408 default:
409 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
410 chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
411 return -1;
412 }
413 fp->fmt_type = fmt[3];
414 if (err < 0)
415 return err;
416#if 1
417 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
418 /* extigy apparently supports sample rates other than 48k
419 * but not in ordinary way. so we enable only 48k atm.
420 */
421 if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
422 chip->usb_id == USB_ID(0x041e, 0x3020) ||
423 chip->usb_id == USB_ID(0x041e, 0x3061)) {
424 if (fmt[3] == UAC_FORMAT_TYPE_I &&
425 fp->rates != SNDRV_PCM_RATE_48000 &&
426 fp->rates != SNDRV_PCM_RATE_96000)
427 return -1;
428 }
429#endif
430 return 0;
431}
432
diff --git a/sound/usb/format.h b/sound/usb/format.h
new file mode 100644
index 000000000000..8298c4e8ddfa
--- /dev/null
+++ b/sound/usb/format.h
@@ -0,0 +1,8 @@
1#ifndef __USBAUDIO_FORMAT_H
2#define __USBAUDIO_FORMAT_H
3
4int snd_usb_parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
5 int format, unsigned char *fmt, int stream,
6 struct usb_host_interface *iface);
7
8#endif /* __USBAUDIO_FORMAT_H */
diff --git a/sound/usb/helper.c b/sound/usb/helper.c
new file mode 100644
index 000000000000..d48d6f8f6ac9
--- /dev/null
+++ b/sound/usb/helper.c
@@ -0,0 +1,113 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 */
17
18#include <linux/init.h>
19#include <linux/slab.h>
20#include <linux/usb.h>
21
22#include "usbaudio.h"
23#include "helper.h"
24
25/*
26 * combine bytes and get an integer value
27 */
28unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
29{
30 switch (size) {
31 case 1: return *bytes;
32 case 2: return combine_word(bytes);
33 case 3: return combine_triple(bytes);
34 case 4: return combine_quad(bytes);
35 default: return 0;
36 }
37}
38
39/*
40 * parse descriptor buffer and return the pointer starting the given
41 * descriptor type.
42 */
43void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype)
44{
45 u8 *p, *end, *next;
46
47 p = descstart;
48 end = p + desclen;
49 for (; p < end;) {
50 if (p[0] < 2)
51 return NULL;
52 next = p + p[0];
53 if (next > end)
54 return NULL;
55 if (p[1] == dtype && (!after || (void *)p > after)) {
56 return p;
57 }
58 p = next;
59 }
60 return NULL;
61}
62
63/*
64 * find a class-specified interface descriptor with the given subtype.
65 */
66void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype)
67{
68 unsigned char *p = after;
69
70 while ((p = snd_usb_find_desc(buffer, buflen, p,
71 USB_DT_CS_INTERFACE)) != NULL) {
72 if (p[0] >= 3 && p[2] == dsubtype)
73 return p;
74 }
75 return NULL;
76}
77
78/*
79 * Wrapper for usb_control_msg().
80 * Allocates a temp buffer to prevent dmaing from/to the stack.
81 */
82int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
83 __u8 requesttype, __u16 value, __u16 index, void *data,
84 __u16 size, int timeout)
85{
86 int err;
87 void *buf = NULL;
88
89 if (size > 0) {
90 buf = kmemdup(data, size, GFP_KERNEL);
91 if (!buf)
92 return -ENOMEM;
93 }
94 err = usb_control_msg(dev, pipe, request, requesttype,
95 value, index, buf, size, timeout);
96 if (size > 0) {
97 memcpy(data, buf, size);
98 kfree(buf);
99 }
100 return err;
101}
102
103unsigned char snd_usb_parse_datainterval(struct snd_usb_audio *chip,
104 struct usb_host_interface *alts)
105{
106 if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH &&
107 get_endpoint(alts, 0)->bInterval >= 1 &&
108 get_endpoint(alts, 0)->bInterval <= 4)
109 return get_endpoint(alts, 0)->bInterval - 1;
110 else
111 return 0;
112}
113
diff --git a/sound/usb/helper.h b/sound/usb/helper.h
new file mode 100644
index 000000000000..a6b0e51b3a9a
--- /dev/null
+++ b/sound/usb/helper.h
@@ -0,0 +1,32 @@
1#ifndef __USBAUDIO_HELPER_H
2#define __USBAUDIO_HELPER_H
3
4unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size);
5
6void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype);
7void *snd_usb_find_csint_desc(void *descstart, int desclen, void *after, u8 dsubtype);
8
9int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe,
10 __u8 request, __u8 requesttype, __u16 value, __u16 index,
11 void *data, __u16 size, int timeout);
12
13unsigned char snd_usb_parse_datainterval(struct snd_usb_audio *chip,
14 struct usb_host_interface *alts);
15
16/*
17 * retrieve usb_interface descriptor from the host interface
18 * (conditional for compatibility with the older API)
19 */
20#ifndef get_iface_desc
21#define get_iface_desc(iface) (&(iface)->desc)
22#define get_endpoint(alt,ep) (&(alt)->endpoint[ep].desc)
23#define get_ep_desc(ep) (&(ep)->desc)
24#define get_cfg_desc(cfg) (&(cfg)->desc)
25#endif
26
27#ifndef snd_usb_get_speed
28#define snd_usb_get_speed(dev) ((dev)->speed)
29#endif
30
31
32#endif /* __USBAUDIO_HELPER_H */
diff --git a/sound/usb/usbmidi.c b/sound/usb/midi.c
index 2c59afd99611..2c1558c327bb 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/midi.c
@@ -53,7 +53,8 @@
53#include <sound/rawmidi.h> 53#include <sound/rawmidi.h>
54#include <sound/asequencer.h> 54#include <sound/asequencer.h>
55#include "usbaudio.h" 55#include "usbaudio.h"
56 56#include "midi.h"
57#include "helper.h"
57 58
58/* 59/*
59 * define this to log all USB packets 60 * define this to log all USB packets
@@ -986,6 +987,8 @@ static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream)
986 DEFINE_WAIT(wait); 987 DEFINE_WAIT(wait);
987 long timeout = msecs_to_jiffies(50); 988 long timeout = msecs_to_jiffies(50);
988 989
990 if (ep->umidi->disconnected)
991 return;
989 /* 992 /*
990 * The substream buffer is empty, but some data might still be in the 993 * The substream buffer is empty, but some data might still be in the
991 * currently active URBs, so we have to wait for those to complete. 994 * currently active URBs, so we have to wait for those to complete.
@@ -1123,14 +1126,21 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
1123 * Frees an output endpoint. 1126 * Frees an output endpoint.
1124 * May be called when ep hasn't been initialized completely. 1127 * May be called when ep hasn't been initialized completely.
1125 */ 1128 */
1126static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep) 1129static void snd_usbmidi_out_endpoint_clear(struct snd_usb_midi_out_endpoint *ep)
1127{ 1130{
1128 unsigned int i; 1131 unsigned int i;
1129 1132
1130 for (i = 0; i < OUTPUT_URBS; ++i) 1133 for (i = 0; i < OUTPUT_URBS; ++i)
1131 if (ep->urbs[i].urb) 1134 if (ep->urbs[i].urb) {
1132 free_urb_and_buffer(ep->umidi, ep->urbs[i].urb, 1135 free_urb_and_buffer(ep->umidi, ep->urbs[i].urb,
1133 ep->max_transfer); 1136 ep->max_transfer);
1137 ep->urbs[i].urb = NULL;
1138 }
1139}
1140
1141static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep)
1142{
1143 snd_usbmidi_out_endpoint_clear(ep);
1134 kfree(ep); 1144 kfree(ep);
1135} 1145}
1136 1146
@@ -1262,15 +1272,18 @@ void snd_usbmidi_disconnect(struct list_head* p)
1262 usb_kill_urb(ep->out->urbs[j].urb); 1272 usb_kill_urb(ep->out->urbs[j].urb);
1263 if (umidi->usb_protocol_ops->finish_out_endpoint) 1273 if (umidi->usb_protocol_ops->finish_out_endpoint)
1264 umidi->usb_protocol_ops->finish_out_endpoint(ep->out); 1274 umidi->usb_protocol_ops->finish_out_endpoint(ep->out);
1275 ep->out->active_urbs = 0;
1276 if (ep->out->drain_urbs) {
1277 ep->out->drain_urbs = 0;
1278 wake_up(&ep->out->drain_wait);
1279 }
1265 } 1280 }
1266 if (ep->in) 1281 if (ep->in)
1267 for (j = 0; j < INPUT_URBS; ++j) 1282 for (j = 0; j < INPUT_URBS; ++j)
1268 usb_kill_urb(ep->in->urbs[j]); 1283 usb_kill_urb(ep->in->urbs[j]);
1269 /* free endpoints here; later call can result in Oops */ 1284 /* free endpoints here; later call can result in Oops */
1270 if (ep->out) { 1285 if (ep->out)
1271 snd_usbmidi_out_endpoint_delete(ep->out); 1286 snd_usbmidi_out_endpoint_clear(ep->out);
1272 ep->out = NULL;
1273 }
1274 if (ep->in) { 1287 if (ep->in) {
1275 snd_usbmidi_in_endpoint_delete(ep->in); 1288 snd_usbmidi_in_endpoint_delete(ep->in);
1276 ep->in = NULL; 1289 ep->in = NULL;
diff --git a/sound/usb/midi.h b/sound/usb/midi.h
new file mode 100644
index 000000000000..2089ec987c66
--- /dev/null
+++ b/sound/usb/midi.h
@@ -0,0 +1,48 @@
1#ifndef __USBMIDI_H
2#define __USBMIDI_H
3
4/* maximum number of endpoints per interface */
5#define MIDI_MAX_ENDPOINTS 2
6
7/* data for QUIRK_MIDI_FIXED_ENDPOINT */
8struct snd_usb_midi_endpoint_info {
9 int8_t out_ep; /* ep number, 0 autodetect */
10 uint8_t out_interval; /* interval for interrupt endpoints */
11 int8_t in_ep;
12 uint8_t in_interval;
13 uint16_t out_cables; /* bitmask */
14 uint16_t in_cables; /* bitmask */
15};
16
17/* for QUIRK_MIDI_YAMAHA, data is NULL */
18
19/* for QUIRK_MIDI_MIDIMAN, data points to a snd_usb_midi_endpoint_info
20 * structure (out_cables and in_cables only) */
21
22/* for QUIRK_COMPOSITE, data points to an array of snd_usb_audio_quirk
23 * structures, terminated with .ifnum = -1 */
24
25/* for QUIRK_AUDIO_FIXED_ENDPOINT, data points to an audioformat structure */
26
27/* for QUIRK_AUDIO/MIDI_STANDARD_INTERFACE, data is NULL */
28
29/* for QUIRK_AUDIO_EDIROL_UA700_UA25/UA1000, data is NULL */
30
31/* for QUIRK_IGNORE_INTERFACE, data is NULL */
32
33/* for QUIRK_MIDI_NOVATION and _RAW, data is NULL */
34
35/* for QUIRK_MIDI_EMAGIC, data points to a snd_usb_midi_endpoint_info
36 * structure (out_cables and in_cables only) */
37
38/* for QUIRK_MIDI_CME, data is NULL */
39
40int snd_usbmidi_create(struct snd_card *card,
41 struct usb_interface *iface,
42 struct list_head *midi_list,
43 const struct snd_usb_audio_quirk *quirk);
44void snd_usbmidi_input_stop(struct list_head* p);
45void snd_usbmidi_input_start(struct list_head* p);
46void snd_usbmidi_disconnect(struct list_head *p);
47
48#endif /* __USBMIDI_H */
diff --git a/sound/usb/misc/Makefile b/sound/usb/misc/Makefile
new file mode 100644
index 000000000000..ccefd8158936
--- /dev/null
+++ b/sound/usb/misc/Makefile
@@ -0,0 +1,2 @@
1snd-ua101-objs := ua101.o
2obj-$(CONFIG_SND_USB_UA101) += snd-ua101.o
diff --git a/sound/usb/ua101.c b/sound/usb/misc/ua101.c
index 3d458d3b9962..796d8b25ee89 100644
--- a/sound/usb/ua101.c
+++ b/sound/usb/misc/ua101.c
@@ -23,7 +23,8 @@
23#include <sound/initval.h> 23#include <sound/initval.h>
24#include <sound/pcm.h> 24#include <sound/pcm.h>
25#include <sound/pcm_params.h> 25#include <sound/pcm_params.h>
26#include "usbaudio.h" 26#include "../usbaudio.h"
27#include "../midi.h"
27 28
28MODULE_DESCRIPTION("Edirol UA-101/1000 driver"); 29MODULE_DESCRIPTION("Edirol UA-101/1000 driver");
29MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); 30MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
diff --git a/sound/usb/usbmixer.c b/sound/usb/mixer.c
index 8e8f871b74ca..1deef623c081 100644
--- a/sound/usb/usbmixer.c
+++ b/sound/usb/mixer.c
@@ -33,6 +33,7 @@
33#include <linux/string.h> 33#include <linux/string.h>
34#include <linux/usb.h> 34#include <linux/usb.h>
35#include <linux/usb/audio.h> 35#include <linux/usb/audio.h>
36#include <linux/usb/audio-v2.h>
36 37
37#include <sound/core.h> 38#include <sound/core.h>
38#include <sound/control.h> 39#include <sound/control.h>
@@ -41,60 +42,12 @@
41#include <sound/tlv.h> 42#include <sound/tlv.h>
42 43
43#include "usbaudio.h" 44#include "usbaudio.h"
44 45#include "mixer.h"
45/* 46#include "helper.h"
46 */ 47#include "mixer_quirks.h"
47
48/* ignore error from controls - for debugging */
49/* #define IGNORE_CTL_ERROR */
50
51/*
52 * Sound Blaster remote control configuration
53 *
54 * format of remote control data:
55 * Extigy: xx 00
56 * Audigy 2 NX: 06 80 xx 00 00 00
57 * Live! 24-bit: 06 80 xx yy 22 83
58 */
59static const struct rc_config {
60 u32 usb_id;
61 u8 offset;
62 u8 length;
63 u8 packet_length;
64 u8 min_packet_length; /* minimum accepted length of the URB result */
65 u8 mute_mixer_id;
66 u32 mute_code;
67} rc_configs[] = {
68 { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
69 { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
70 { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
71 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
72};
73 48
74#define MAX_ID_ELEMS 256 49#define MAX_ID_ELEMS 256
75 50
76struct usb_mixer_interface {
77 struct snd_usb_audio *chip;
78 unsigned int ctrlif;
79 struct list_head list;
80 unsigned int ignore_ctl_error;
81 struct urb *urb;
82 /* array[MAX_ID_ELEMS], indexed by unit id */
83 struct usb_mixer_elem_info **id_elems;
84
85 /* Sound Blaster remote control stuff */
86 const struct rc_config *rc_cfg;
87 u32 rc_code;
88 wait_queue_head_t rc_waitq;
89 struct urb *rc_urb;
90 struct usb_ctrlrequest *rc_setup_packet;
91 u8 rc_buffer[6];
92
93 u8 audigy2nx_leds[3];
94 u8 xonar_u1_status;
95};
96
97
98struct usb_audio_term { 51struct usb_audio_term {
99 int id; 52 int id;
100 int type; 53 int type;
@@ -116,39 +69,6 @@ struct mixer_build {
116 const struct usbmix_selector_map *selector_map; 69 const struct usbmix_selector_map *selector_map;
117}; 70};
118 71
119#define MAX_CHANNELS 10 /* max logical channels */
120
121struct usb_mixer_elem_info {
122 struct usb_mixer_interface *mixer;
123 struct usb_mixer_elem_info *next_id_elem; /* list of controls with same id */
124 struct snd_ctl_elem_id *elem_id;
125 unsigned int id;
126 unsigned int control; /* CS or ICN (high byte) */
127 unsigned int cmask; /* channel mask bitmap: 0 = master */
128 int channels;
129 int val_type;
130 int min, max, res;
131 int dBmin, dBmax;
132 int cached;
133 int cache_val[MAX_CHANNELS];
134 u8 initialized;
135};
136
137
138enum {
139 USB_FEATURE_NONE = 0,
140 USB_FEATURE_MUTE = 1,
141 USB_FEATURE_VOLUME,
142 USB_FEATURE_BASS,
143 USB_FEATURE_MID,
144 USB_FEATURE_TREBLE,
145 USB_FEATURE_GEQ,
146 USB_FEATURE_AGC,
147 USB_FEATURE_DELAY,
148 USB_FEATURE_BASSBOOST,
149 USB_FEATURE_LOUDNESS
150};
151
152enum { 72enum {
153 USB_MIXER_BOOLEAN, 73 USB_MIXER_BOOLEAN,
154 USB_MIXER_INV_BOOLEAN, 74 USB_MIXER_INV_BOOLEAN,
@@ -213,7 +133,7 @@ enum {
213 * if the mixer topology is too complicated and the parsed names are 133 * if the mixer topology is too complicated and the parsed names are
214 * ambiguous, add the entries in usbmixer_maps.c. 134 * ambiguous, add the entries in usbmixer_maps.c.
215 */ 135 */
216#include "usbmixer_maps.c" 136#include "mixer_maps.c"
217 137
218static const struct usbmix_name_map * 138static const struct usbmix_name_map *
219find_map(struct mixer_build *state, int unitid, int control) 139find_map(struct mixer_build *state, int unitid, int control)
@@ -278,6 +198,7 @@ static int check_mapped_selector_name(struct mixer_build *state, int unitid,
278 198
279/* 199/*
280 * find an audio control unit with the given unit id 200 * find an audio control unit with the given unit id
201 * this doesn't return any clock related units, so they need to be handled elsewhere
281 */ 202 */
282static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit) 203static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit)
283{ 204{
@@ -286,7 +207,7 @@ static void *find_audio_control_unit(struct mixer_build *state, unsigned char un
286 p = NULL; 207 p = NULL;
287 while ((p = snd_usb_find_desc(state->buffer, state->buflen, p, 208 while ((p = snd_usb_find_desc(state->buffer, state->buflen, p,
288 USB_DT_CS_INTERFACE)) != NULL) { 209 USB_DT_CS_INTERFACE)) != NULL) {
289 if (p[0] >= 4 && p[2] >= UAC_INPUT_TERMINAL && p[2] <= UAC_EXTENSION_UNIT_V1 && p[3] == unit) 210 if (p[0] >= 4 && p[2] >= UAC_INPUT_TERMINAL && p[2] <= UAC2_EXTENSION_UNIT_V2 && p[3] == unit)
290 return p; 211 return p;
291 } 212 }
292 return NULL; 213 return NULL;
@@ -383,7 +304,7 @@ static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
383 * retrieve a mixer value 304 * retrieve a mixer value
384 */ 305 */
385 306
386static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret) 307static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
387{ 308{
388 unsigned char buf[2]; 309 unsigned char buf[2];
389 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; 310 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
@@ -405,6 +326,58 @@ static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali
405 return -EINVAL; 326 return -EINVAL;
406} 327}
407 328
329static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
330{
331 unsigned char buf[14]; /* enough space for one range of 4 bytes */
332 unsigned char *val;
333 int ret;
334 __u8 bRequest;
335
336 bRequest = (request == UAC_GET_CUR) ?
337 UAC2_CS_CUR : UAC2_CS_RANGE;
338
339 ret = snd_usb_ctl_msg(cval->mixer->chip->dev,
340 usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
341 bRequest,
342 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
343 validx, cval->mixer->ctrlif | (cval->id << 8),
344 buf, sizeof(buf), 1000);
345
346 if (ret < 0) {
347 snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
348 request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
349 return ret;
350 }
351
352 switch (request) {
353 case UAC_GET_CUR:
354 val = buf;
355 break;
356 case UAC_GET_MIN:
357 val = buf + sizeof(__u16);
358 break;
359 case UAC_GET_MAX:
360 val = buf + sizeof(__u16) * 2;
361 break;
362 case UAC_GET_RES:
363 val = buf + sizeof(__u16) * 3;
364 break;
365 default:
366 return -EINVAL;
367 }
368
369 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(val, sizeof(__u16)));
370
371 return 0;
372}
373
374static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
375{
376 return (cval->mixer->protocol == UAC_VERSION_1) ?
377 get_ctl_value_v1(cval, request, validx, value_ret) :
378 get_ctl_value_v2(cval, request, validx, value_ret);
379}
380
408static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value) 381static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value)
409{ 382{
410 return get_ctl_value(cval, UAC_GET_CUR, validx, value); 383 return get_ctl_value(cval, UAC_GET_CUR, validx, value);
@@ -429,8 +402,7 @@ static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
429 err = get_cur_mix_raw(cval, channel, value); 402 err = get_cur_mix_raw(cval, channel, value);
430 if (err < 0) { 403 if (err < 0) {
431 if (!cval->mixer->ignore_ctl_error) 404 if (!cval->mixer->ignore_ctl_error)
432 snd_printd(KERN_ERR "cannot get current value for " 405 snd_printd(KERN_ERR "cannot get current value for control %d ch %d: err = %d\n",
433 "control %d ch %d: err = %d\n",
434 cval->control, channel, err); 406 cval->control, channel, err);
435 return err; 407 return err;
436 } 408 }
@@ -444,11 +416,26 @@ static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
444 * set a mixer value 416 * set a mixer value
445 */ 417 */
446 418
447static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int value_set) 419int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
420 int request, int validx, int value_set)
448{ 421{
449 unsigned char buf[2]; 422 unsigned char buf[2];
450 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; 423 int val_len, timeout = 10;
451 int timeout = 10; 424
425 if (cval->mixer->protocol == UAC_VERSION_1) {
426 val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
427 } else { /* UAC_VERSION_2 */
428 /* audio class v2 controls are always 2 bytes in size */
429 val_len = sizeof(__u16);
430
431 /* FIXME */
432 if (request != UAC_SET_CUR) {
433 snd_printdd(KERN_WARNING "RANGE setting not yet supported\n");
434 return -EINVAL;
435 }
436
437 request = UAC2_CS_CUR;
438 }
452 439
453 value_set = convert_bytes_value(cval, value_set); 440 value_set = convert_bytes_value(cval, value_set);
454 buf[0] = value_set & 0xff; 441 buf[0] = value_set & 0xff;
@@ -468,14 +455,14 @@ static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali
468 455
469static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value) 456static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value)
470{ 457{
471 return set_ctl_value(cval, UAC_SET_CUR, validx, value); 458 return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value);
472} 459}
473 460
474static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, 461static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
475 int index, int value) 462 int index, int value)
476{ 463{
477 int err; 464 int err;
478 err = set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel, 465 err = snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
479 value); 466 value);
480 if (err < 0) 467 if (err < 0)
481 return err; 468 return err;
@@ -644,46 +631,65 @@ static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm
644 */ 631 */
645static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term) 632static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term)
646{ 633{
647 unsigned char *p1; 634 void *p1;
648 635
649 memset(term, 0, sizeof(*term)); 636 memset(term, 0, sizeof(*term));
650 while ((p1 = find_audio_control_unit(state, id)) != NULL) { 637 while ((p1 = find_audio_control_unit(state, id)) != NULL) {
638 unsigned char *hdr = p1;
651 term->id = id; 639 term->id = id;
652 switch (p1[2]) { 640 switch (hdr[2]) {
653 case UAC_INPUT_TERMINAL: 641 case UAC_INPUT_TERMINAL:
654 term->type = combine_word(p1 + 4); 642 if (state->mixer->protocol == UAC_VERSION_1) {
655 term->channels = p1[7]; 643 struct uac_input_terminal_descriptor *d = p1;
656 term->chconfig = combine_word(p1 + 8); 644 term->type = le16_to_cpu(d->wTerminalType);
657 term->name = p1[11]; 645 term->channels = d->bNrChannels;
646 term->chconfig = le16_to_cpu(d->wChannelConfig);
647 term->name = d->iTerminal;
648 } else { /* UAC_VERSION_2 */
649 struct uac2_input_terminal_descriptor *d = p1;
650 term->type = le16_to_cpu(d->wTerminalType);
651 term->channels = d->bNrChannels;
652 term->chconfig = le32_to_cpu(d->bmChannelConfig);
653 term->name = d->iTerminal;
654 }
658 return 0; 655 return 0;
659 case UAC_FEATURE_UNIT: 656 case UAC_FEATURE_UNIT: {
660 id = p1[4]; 657 /* the header is the same for v1 and v2 */
658 struct uac_feature_unit_descriptor *d = p1;
659 id = d->bUnitID;
661 break; /* continue to parse */ 660 break; /* continue to parse */
662 case UAC_MIXER_UNIT: 661 }
663 term->type = p1[2] << 16; /* virtual type */ 662 case UAC_MIXER_UNIT: {
664 term->channels = p1[5 + p1[4]]; 663 struct uac_mixer_unit_descriptor *d = p1;
665 term->chconfig = combine_word(p1 + 6 + p1[4]); 664 term->type = d->bDescriptorSubtype << 16; /* virtual type */
666 term->name = p1[p1[0] - 1]; 665 term->channels = uac_mixer_unit_bNrChannels(d);
666 term->chconfig = uac_mixer_unit_wChannelConfig(d, state->mixer->protocol);
667 term->name = uac_mixer_unit_iMixer(d);
667 return 0; 668 return 0;
668 case UAC_SELECTOR_UNIT: 669 }
670 case UAC_SELECTOR_UNIT: {
671 struct uac_selector_unit_descriptor *d = p1;
669 /* call recursively to retrieve the channel info */ 672 /* call recursively to retrieve the channel info */
670 if (check_input_term(state, p1[5], term) < 0) 673 if (check_input_term(state, d->baSourceID[0], term) < 0)
671 return -ENODEV; 674 return -ENODEV;
672 term->type = p1[2] << 16; /* virtual type */ 675 term->type = d->bDescriptorSubtype << 16; /* virtual type */
673 term->id = id; 676 term->id = id;
674 term->name = p1[9 + p1[0] - 1]; 677 term->name = uac_selector_unit_iSelector(d);
675 return 0; 678 return 0;
679 }
676 case UAC_PROCESSING_UNIT_V1: 680 case UAC_PROCESSING_UNIT_V1:
677 case UAC_EXTENSION_UNIT_V1: 681 case UAC_EXTENSION_UNIT_V1: {
678 if (p1[6] == 1) { 682 struct uac_processing_unit_descriptor *d = p1;
679 id = p1[7]; 683 if (d->bNrInPins) {
684 id = d->baSourceID[0];
680 break; /* continue to parse */ 685 break; /* continue to parse */
681 } 686 }
682 term->type = p1[2] << 16; /* virtual type */ 687 term->type = d->bDescriptorSubtype << 16; /* virtual type */
683 term->channels = p1[7 + p1[6]]; 688 term->channels = uac_processing_unit_bNrChannels(d);
684 term->chconfig = combine_word(p1 + 8 + p1[6]); 689 term->chconfig = uac_processing_unit_wChannelConfig(d, state->mixer->protocol);
685 term->name = p1[12 + p1[6] + p1[11 + p1[6]]]; 690 term->name = uac_processing_unit_iProcessing(d, state->mixer->protocol);
686 return 0; 691 return 0;
692 }
687 default: 693 default:
688 return -ENODEV; 694 return -ENODEV;
689 } 695 }
@@ -764,7 +770,8 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
764 int last_valid_res = cval->res; 770 int last_valid_res = cval->res;
765 771
766 while (cval->res > 1) { 772 while (cval->res > 1) {
767 if (set_ctl_value(cval, UAC_SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0) 773 if (snd_usb_mixer_set_ctl_value(cval, UAC_SET_RES,
774 (cval->control << 8) | minchn, cval->res / 2) < 0)
768 break; 775 break;
769 cval->res /= 2; 776 cval->res /= 2;
770 } 777 }
@@ -929,6 +936,15 @@ static struct snd_kcontrol_new usb_feature_unit_ctl = {
929 .put = mixer_ctl_feature_put, 936 .put = mixer_ctl_feature_put,
930}; 937};
931 938
939/* the read-only variant */
940static struct snd_kcontrol_new usb_feature_unit_ctl_ro = {
941 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
942 .name = "", /* will be filled later manually */
943 .info = mixer_ctl_feature_info,
944 .get = mixer_ctl_feature_get,
945 .put = NULL,
946};
947
932 948
933/* 949/*
934 * build a feature control 950 * build a feature control
@@ -939,20 +955,22 @@ static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str)
939 return strlcat(kctl->id.name, str, sizeof(kctl->id.name)); 955 return strlcat(kctl->id.name, str, sizeof(kctl->id.name));
940} 956}
941 957
942static void build_feature_ctl(struct mixer_build *state, unsigned char *desc, 958static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
943 unsigned int ctl_mask, int control, 959 unsigned int ctl_mask, int control,
944 struct usb_audio_term *iterm, int unitid) 960 struct usb_audio_term *iterm, int unitid,
961 int read_only)
945{ 962{
963 struct uac_feature_unit_descriptor *desc = raw_desc;
946 unsigned int len = 0; 964 unsigned int len = 0;
947 int mapped_name = 0; 965 int mapped_name = 0;
948 int nameid = desc[desc[0] - 1]; 966 int nameid = uac_feature_unit_iFeature(desc);
949 struct snd_kcontrol *kctl; 967 struct snd_kcontrol *kctl;
950 struct usb_mixer_elem_info *cval; 968 struct usb_mixer_elem_info *cval;
951 const struct usbmix_name_map *map; 969 const struct usbmix_name_map *map;
952 970
953 control++; /* change from zero-based to 1-based value */ 971 control++; /* change from zero-based to 1-based value */
954 972
955 if (control == USB_FEATURE_GEQ) { 973 if (control == UAC_GRAPHIC_EQUALIZER_CONTROL) {
956 /* FIXME: not supported yet */ 974 /* FIXME: not supported yet */
957 return; 975 return;
958 } 976 }
@@ -984,7 +1002,11 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
984 /* get min/max values */ 1002 /* get min/max values */
985 get_min_max(cval, 0); 1003 get_min_max(cval, 0);
986 1004
987 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval); 1005 if (read_only)
1006 kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
1007 else
1008 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1009
988 if (! kctl) { 1010 if (! kctl) {
989 snd_printk(KERN_ERR "cannot malloc kcontrol\n"); 1011 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
990 kfree(cval); 1012 kfree(cval);
@@ -999,8 +1021,8 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
999 kctl->id.name, sizeof(kctl->id.name)); 1021 kctl->id.name, sizeof(kctl->id.name));
1000 1022
1001 switch (control) { 1023 switch (control) {
1002 case USB_FEATURE_MUTE: 1024 case UAC_MUTE_CONTROL:
1003 case USB_FEATURE_VOLUME: 1025 case UAC_VOLUME_CONTROL:
1004 /* determine the control name. the rule is: 1026 /* determine the control name. the rule is:
1005 * - if a name id is given in descriptor, use it. 1027 * - if a name id is given in descriptor, use it.
1006 * - if the connected input can be determined, then use the name 1028 * - if the connected input can be determined, then use the name
@@ -1027,9 +1049,9 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
1027 len = append_ctl_name(kctl, " Playback"); 1049 len = append_ctl_name(kctl, " Playback");
1028 } 1050 }
1029 } 1051 }
1030 append_ctl_name(kctl, control == USB_FEATURE_MUTE ? 1052 append_ctl_name(kctl, control == UAC_MUTE_CONTROL ?
1031 " Switch" : " Volume"); 1053 " Switch" : " Volume");
1032 if (control == USB_FEATURE_VOLUME) { 1054 if (control == UAC_VOLUME_CONTROL) {
1033 kctl->tlv.c = mixer_vol_tlv; 1055 kctl->tlv.c = mixer_vol_tlv;
1034 kctl->vd[0].access |= 1056 kctl->vd[0].access |=
1035 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 1057 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
@@ -1094,49 +1116,92 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
1094 struct usb_audio_term iterm; 1116 struct usb_audio_term iterm;
1095 unsigned int master_bits, first_ch_bits; 1117 unsigned int master_bits, first_ch_bits;
1096 int err, csize; 1118 int err, csize;
1097 struct uac_feature_unit_descriptor *ftr = _ftr; 1119 struct uac_feature_unit_descriptor *hdr = _ftr;
1120 __u8 *bmaControls;
1121
1122 if (state->mixer->protocol == UAC_VERSION_1) {
1123 csize = hdr->bControlSize;
1124 channels = (hdr->bLength - 7) / csize - 1;
1125 bmaControls = hdr->bmaControls;
1126 } else {
1127 struct uac2_feature_unit_descriptor *ftr = _ftr;
1128 csize = 4;
1129 channels = (hdr->bLength - 6) / 4;
1130 bmaControls = ftr->bmaControls;
1131 }
1098 1132
1099 if (ftr->bLength < 7 || ! (csize = ftr->bControlSize) || ftr->bLength < 7 + csize) { 1133 if (hdr->bLength < 7 || !csize || hdr->bLength < 7 + csize) {
1100 snd_printk(KERN_ERR "usbaudio: unit %u: invalid UAC_FEATURE_UNIT descriptor\n", unitid); 1134 snd_printk(KERN_ERR "usbaudio: unit %u: invalid UAC_FEATURE_UNIT descriptor\n", unitid);
1101 return -EINVAL; 1135 return -EINVAL;
1102 } 1136 }
1103 1137
1104 /* parse the source unit */ 1138 /* parse the source unit */
1105 if ((err = parse_audio_unit(state, ftr->bSourceID)) < 0) 1139 if ((err = parse_audio_unit(state, hdr->bSourceID)) < 0)
1106 return err; 1140 return err;
1107 1141
1108 /* determine the input source type and name */ 1142 /* determine the input source type and name */
1109 if (check_input_term(state, ftr->bSourceID, &iterm) < 0) 1143 if (check_input_term(state, hdr->bSourceID, &iterm) < 0)
1110 return -EINVAL; 1144 return -EINVAL;
1111 1145
1112 channels = (ftr->bLength - 7) / csize - 1; 1146 master_bits = snd_usb_combine_bytes(bmaControls, csize);
1113
1114 master_bits = snd_usb_combine_bytes(ftr->controls, csize);
1115 /* master configuration quirks */ 1147 /* master configuration quirks */
1116 switch (state->chip->usb_id) { 1148 switch (state->chip->usb_id) {
1117 case USB_ID(0x08bb, 0x2702): 1149 case USB_ID(0x08bb, 0x2702):
1118 snd_printk(KERN_INFO 1150 snd_printk(KERN_INFO
1119 "usbmixer: master volume quirk for PCM2702 chip\n"); 1151 "usbmixer: master volume quirk for PCM2702 chip\n");
1120 /* disable non-functional volume control */ 1152 /* disable non-functional volume control */
1121 master_bits &= ~(1 << (USB_FEATURE_VOLUME - 1)); 1153 master_bits &= ~UAC_FU_VOLUME;
1122 break; 1154 break;
1123 } 1155 }
1124 if (channels > 0) 1156 if (channels > 0)
1125 first_ch_bits = snd_usb_combine_bytes(ftr->controls + csize, csize); 1157 first_ch_bits = snd_usb_combine_bytes(bmaControls + csize, csize);
1126 else 1158 else
1127 first_ch_bits = 0; 1159 first_ch_bits = 0;
1128 /* check all control types */ 1160
1129 for (i = 0; i < 10; i++) { 1161 if (state->mixer->protocol == UAC_VERSION_1) {
1130 unsigned int ch_bits = 0; 1162 /* check all control types */
1131 for (j = 0; j < channels; j++) { 1163 for (i = 0; i < 10; i++) {
1132 unsigned int mask = snd_usb_combine_bytes(ftr->controls + csize * (j+1), csize); 1164 unsigned int ch_bits = 0;
1133 if (mask & (1 << i)) 1165 for (j = 0; j < channels; j++) {
1134 ch_bits |= (1 << j); 1166 unsigned int mask = snd_usb_combine_bytes(bmaControls + csize * (j+1), csize);
1167 if (mask & (1 << i))
1168 ch_bits |= (1 << j);
1169 }
1170 /* audio class v1 controls are never read-only */
1171 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
1172 build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid, 0);
1173 if (master_bits & (1 << i))
1174 build_feature_ctl(state, _ftr, 0, i, &iterm, unitid, 0);
1175 }
1176 } else { /* UAC_VERSION_2 */
1177 for (i = 0; i < 30/2; i++) {
1178 /* From the USB Audio spec v2.0:
1179 bmaControls() is a (ch+1)-element array of 4-byte bitmaps,
1180 each containing a set of bit pairs. If a Control is present,
1181 it must be Host readable. If a certain Control is not
1182 present then the bit pair must be set to 0b00.
1183 If a Control is present but read-only, the bit pair must be
1184 set to 0b01. If a Control is also Host programmable, the bit
1185 pair must be set to 0b11. The value 0b10 is not allowed. */
1186 unsigned int ch_bits = 0;
1187 unsigned int ch_read_only = 0;
1188
1189 for (j = 0; j < channels; j++) {
1190 unsigned int mask = snd_usb_combine_bytes(bmaControls + csize * (j+1), csize);
1191 if (mask & (1 << (i * 2))) {
1192 ch_bits |= (1 << j);
1193 if (~mask & (1 << ((i * 2) + 1)))
1194 ch_read_only |= (1 << j);
1195 }
1196 }
1197
1198 /* FIXME: the whole unit is read-only if any of the channels is marked read-only */
1199 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
1200 build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid, !!ch_read_only);
1201 if (master_bits & (1 << i * 2))
1202 build_feature_ctl(state, _ftr, 0, i, &iterm, unitid,
1203 ~master_bits & (1 << ((i * 2) + 1)));
1135 } 1204 }
1136 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
1137 build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid);
1138 if (master_bits & (1 << i))
1139 build_feature_ctl(state, _ftr, 0, i, &iterm, unitid);
1140 } 1205 }
1141 1206
1142 return 0; 1207 return 0;
@@ -1154,13 +1219,13 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
1154 * input channel number (zero based) is given in control field instead. 1219 * input channel number (zero based) is given in control field instead.
1155 */ 1220 */
1156 1221
1157static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc, 1222static void build_mixer_unit_ctl(struct mixer_build *state,
1223 struct uac_mixer_unit_descriptor *desc,
1158 int in_pin, int in_ch, int unitid, 1224 int in_pin, int in_ch, int unitid,
1159 struct usb_audio_term *iterm) 1225 struct usb_audio_term *iterm)
1160{ 1226{
1161 struct usb_mixer_elem_info *cval; 1227 struct usb_mixer_elem_info *cval;
1162 unsigned int input_pins = desc[4]; 1228 unsigned int num_outs = uac_mixer_unit_bNrChannels(desc);
1163 unsigned int num_outs = desc[5 + input_pins];
1164 unsigned int i, len; 1229 unsigned int i, len;
1165 struct snd_kcontrol *kctl; 1230 struct snd_kcontrol *kctl;
1166 const struct usbmix_name_map *map; 1231 const struct usbmix_name_map *map;
@@ -1178,7 +1243,7 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
1178 cval->control = in_ch + 1; /* based on 1 */ 1243 cval->control = in_ch + 1; /* based on 1 */
1179 cval->val_type = USB_MIXER_S16; 1244 cval->val_type = USB_MIXER_S16;
1180 for (i = 0; i < num_outs; i++) { 1245 for (i = 0; i < num_outs; i++) {
1181 if (check_matrix_bitmap(desc + 9 + input_pins, in_ch, i, num_outs)) { 1246 if (check_matrix_bitmap(uac_mixer_unit_bmControls(desc, state->mixer->protocol), in_ch, i, num_outs)) {
1182 cval->cmask |= (1 << i); 1247 cval->cmask |= (1 << i);
1183 cval->channels++; 1248 cval->channels++;
1184 } 1249 }
@@ -1211,18 +1276,19 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
1211/* 1276/*
1212 * parse a mixer unit 1277 * parse a mixer unit
1213 */ 1278 */
1214static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, unsigned char *desc) 1279static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, void *raw_desc)
1215{ 1280{
1281 struct uac_mixer_unit_descriptor *desc = raw_desc;
1216 struct usb_audio_term iterm; 1282 struct usb_audio_term iterm;
1217 int input_pins, num_ins, num_outs; 1283 int input_pins, num_ins, num_outs;
1218 int pin, ich, err; 1284 int pin, ich, err;
1219 1285
1220 if (desc[0] < 11 || ! (input_pins = desc[4]) || ! (num_outs = desc[5 + input_pins])) { 1286 if (desc->bLength < 11 || ! (input_pins = desc->bNrInPins) || ! (num_outs = uac_mixer_unit_bNrChannels(desc))) {
1221 snd_printk(KERN_ERR "invalid MIXER UNIT descriptor %d\n", unitid); 1287 snd_printk(KERN_ERR "invalid MIXER UNIT descriptor %d\n", unitid);
1222 return -EINVAL; 1288 return -EINVAL;
1223 } 1289 }
1224 /* no bmControls field (e.g. Maya44) -> ignore */ 1290 /* no bmControls field (e.g. Maya44) -> ignore */
1225 if (desc[0] <= 10 + input_pins) { 1291 if (desc->bLength <= 10 + input_pins) {
1226 snd_printdd(KERN_INFO "MU %d has no bmControls field\n", unitid); 1292 snd_printdd(KERN_INFO "MU %d has no bmControls field\n", unitid);
1227 return 0; 1293 return 0;
1228 } 1294 }
@@ -1230,10 +1296,10 @@ static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, unsigne
1230 num_ins = 0; 1296 num_ins = 0;
1231 ich = 0; 1297 ich = 0;
1232 for (pin = 0; pin < input_pins; pin++) { 1298 for (pin = 0; pin < input_pins; pin++) {
1233 err = parse_audio_unit(state, desc[5 + pin]); 1299 err = parse_audio_unit(state, desc->baSourceID[pin]);
1234 if (err < 0) 1300 if (err < 0)
1235 return err; 1301 return err;
1236 err = check_input_term(state, desc[5 + pin], &iterm); 1302 err = check_input_term(state, desc->baSourceID[pin], &iterm);
1237 if (err < 0) 1303 if (err < 0)
1238 return err; 1304 return err;
1239 num_ins += iterm.channels; 1305 num_ins += iterm.channels;
@@ -1241,7 +1307,7 @@ static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, unsigne
1241 int och, ich_has_controls = 0; 1307 int och, ich_has_controls = 0;
1242 1308
1243 for (och = 0; och < num_outs; ++och) { 1309 for (och = 0; och < num_outs; ++och) {
1244 if (check_matrix_bitmap(desc + 9 + input_pins, 1310 if (check_matrix_bitmap(uac_mixer_unit_bmControls(desc, state->mixer->protocol),
1245 ich, och, num_outs)) { 1311 ich, och, num_outs)) {
1246 ich_has_controls = 1; 1312 ich_has_controls = 1;
1247 break; 1313 break;
@@ -1402,9 +1468,10 @@ static struct procunit_info extunits[] = {
1402/* 1468/*
1403 * build a processing/extension unit 1469 * build a processing/extension unit
1404 */ 1470 */
1405static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name) 1471static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw_desc, struct procunit_info *list, char *name)
1406{ 1472{
1407 int num_ins = dsc[6]; 1473 struct uac_processing_unit_descriptor *desc = raw_desc;
1474 int num_ins = desc->bNrInPins;
1408 struct usb_mixer_elem_info *cval; 1475 struct usb_mixer_elem_info *cval;
1409 struct snd_kcontrol *kctl; 1476 struct snd_kcontrol *kctl;
1410 int i, err, nameid, type, len; 1477 int i, err, nameid, type, len;
@@ -1419,17 +1486,18 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
1419 0, NULL, default_value_info 1486 0, NULL, default_value_info
1420 }; 1487 };
1421 1488
1422 if (dsc[0] < 13 || dsc[0] < 13 + num_ins || dsc[0] < num_ins + dsc[11 + num_ins]) { 1489 if (desc->bLength < 13 || desc->bLength < 13 + num_ins ||
1490 desc->bLength < num_ins + uac_processing_unit_bControlSize(desc, state->mixer->protocol)) {
1423 snd_printk(KERN_ERR "invalid %s descriptor (id %d)\n", name, unitid); 1491 snd_printk(KERN_ERR "invalid %s descriptor (id %d)\n", name, unitid);
1424 return -EINVAL; 1492 return -EINVAL;
1425 } 1493 }
1426 1494
1427 for (i = 0; i < num_ins; i++) { 1495 for (i = 0; i < num_ins; i++) {
1428 if ((err = parse_audio_unit(state, dsc[7 + i])) < 0) 1496 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1429 return err; 1497 return err;
1430 } 1498 }
1431 1499
1432 type = combine_word(&dsc[4]); 1500 type = le16_to_cpu(desc->wProcessType);
1433 for (info = list; info && info->type; info++) 1501 for (info = list; info && info->type; info++)
1434 if (info->type == type) 1502 if (info->type == type)
1435 break; 1503 break;
@@ -1437,8 +1505,9 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
1437 info = &default_info; 1505 info = &default_info;
1438 1506
1439 for (valinfo = info->values; valinfo->control; valinfo++) { 1507 for (valinfo = info->values; valinfo->control; valinfo++) {
1440 /* FIXME: bitmap might be longer than 8bit */ 1508 __u8 *controls = uac_processing_unit_bmControls(desc, state->mixer->protocol);
1441 if (! (dsc[12 + num_ins] & (1 << (valinfo->control - 1)))) 1509
1510 if (! (controls[valinfo->control / 8] & (1 << ((valinfo->control % 8) - 1))))
1442 continue; 1511 continue;
1443 map = find_map(state, unitid, valinfo->control); 1512 map = find_map(state, unitid, valinfo->control);
1444 if (check_ignored_ctl(map)) 1513 if (check_ignored_ctl(map))
@@ -1456,9 +1525,10 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
1456 1525
1457 /* get min/max values */ 1526 /* get min/max values */
1458 if (type == USB_PROC_UPDOWN && cval->control == USB_PROC_UPDOWN_MODE_SEL) { 1527 if (type == USB_PROC_UPDOWN && cval->control == USB_PROC_UPDOWN_MODE_SEL) {
1528 __u8 *control_spec = uac_processing_unit_specific(desc, state->mixer->protocol);
1459 /* FIXME: hard-coded */ 1529 /* FIXME: hard-coded */
1460 cval->min = 1; 1530 cval->min = 1;
1461 cval->max = dsc[15]; 1531 cval->max = control_spec[0];
1462 cval->res = 1; 1532 cval->res = 1;
1463 cval->initialized = 1; 1533 cval->initialized = 1;
1464 } else { 1534 } else {
@@ -1488,7 +1558,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
1488 else if (info->name) 1558 else if (info->name)
1489 strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name)); 1559 strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name));
1490 else { 1560 else {
1491 nameid = dsc[12 + num_ins + dsc[11 + num_ins]]; 1561 nameid = uac_processing_unit_iProcessing(desc, state->mixer->protocol);
1492 len = 0; 1562 len = 0;
1493 if (nameid) 1563 if (nameid)
1494 len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name)); 1564 len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
@@ -1507,14 +1577,16 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
1507} 1577}
1508 1578
1509 1579
1510static int parse_audio_processing_unit(struct mixer_build *state, int unitid, unsigned char *desc) 1580static int parse_audio_processing_unit(struct mixer_build *state, int unitid, void *raw_desc)
1511{ 1581{
1512 return build_audio_procunit(state, unitid, desc, procunits, "Processing Unit"); 1582 return build_audio_procunit(state, unitid, raw_desc, procunits, "Processing Unit");
1513} 1583}
1514 1584
1515static int parse_audio_extension_unit(struct mixer_build *state, int unitid, unsigned char *desc) 1585static int parse_audio_extension_unit(struct mixer_build *state, int unitid, void *raw_desc)
1516{ 1586{
1517 return build_audio_procunit(state, unitid, desc, extunits, "Extension Unit"); 1587 /* Note that we parse extension units with processing unit descriptors.
1588 * That's ok as the layout is the same */
1589 return build_audio_procunit(state, unitid, raw_desc, extunits, "Extension Unit");
1518} 1590}
1519 1591
1520 1592
@@ -1616,9 +1688,9 @@ static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl)
1616/* 1688/*
1617 * parse a selector unit 1689 * parse a selector unit
1618 */ 1690 */
1619static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsigned char *desc) 1691static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void *raw_desc)
1620{ 1692{
1621 unsigned int num_ins = desc[4]; 1693 struct uac_selector_unit_descriptor *desc = raw_desc;
1622 unsigned int i, nameid, len; 1694 unsigned int i, nameid, len;
1623 int err; 1695 int err;
1624 struct usb_mixer_elem_info *cval; 1696 struct usb_mixer_elem_info *cval;
@@ -1626,17 +1698,17 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
1626 const struct usbmix_name_map *map; 1698 const struct usbmix_name_map *map;
1627 char **namelist; 1699 char **namelist;
1628 1700
1629 if (! num_ins || desc[0] < 5 + num_ins) { 1701 if (!desc->bNrInPins || desc->bLength < 5 + desc->bNrInPins) {
1630 snd_printk(KERN_ERR "invalid SELECTOR UNIT descriptor %d\n", unitid); 1702 snd_printk(KERN_ERR "invalid SELECTOR UNIT descriptor %d\n", unitid);
1631 return -EINVAL; 1703 return -EINVAL;
1632 } 1704 }
1633 1705
1634 for (i = 0; i < num_ins; i++) { 1706 for (i = 0; i < desc->bNrInPins; i++) {
1635 if ((err = parse_audio_unit(state, desc[5 + i])) < 0) 1707 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1636 return err; 1708 return err;
1637 } 1709 }
1638 1710
1639 if (num_ins == 1) /* only one ? nonsense! */ 1711 if (desc->bNrInPins == 1) /* only one ? nonsense! */
1640 return 0; 1712 return 0;
1641 1713
1642 map = find_map(state, unitid, 0); 1714 map = find_map(state, unitid, 0);
@@ -1653,18 +1725,18 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
1653 cval->val_type = USB_MIXER_U8; 1725 cval->val_type = USB_MIXER_U8;
1654 cval->channels = 1; 1726 cval->channels = 1;
1655 cval->min = 1; 1727 cval->min = 1;
1656 cval->max = num_ins; 1728 cval->max = desc->bNrInPins;
1657 cval->res = 1; 1729 cval->res = 1;
1658 cval->initialized = 1; 1730 cval->initialized = 1;
1659 1731
1660 namelist = kmalloc(sizeof(char *) * num_ins, GFP_KERNEL); 1732 namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL);
1661 if (! namelist) { 1733 if (! namelist) {
1662 snd_printk(KERN_ERR "cannot malloc\n"); 1734 snd_printk(KERN_ERR "cannot malloc\n");
1663 kfree(cval); 1735 kfree(cval);
1664 return -ENOMEM; 1736 return -ENOMEM;
1665 } 1737 }
1666#define MAX_ITEM_NAME_LEN 64 1738#define MAX_ITEM_NAME_LEN 64
1667 for (i = 0; i < num_ins; i++) { 1739 for (i = 0; i < desc->bNrInPins; i++) {
1668 struct usb_audio_term iterm; 1740 struct usb_audio_term iterm;
1669 len = 0; 1741 len = 0;
1670 namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL); 1742 namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
@@ -1678,7 +1750,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
1678 } 1750 }
1679 len = check_mapped_selector_name(state, unitid, i, namelist[i], 1751 len = check_mapped_selector_name(state, unitid, i, namelist[i],
1680 MAX_ITEM_NAME_LEN); 1752 MAX_ITEM_NAME_LEN);
1681 if (! len && check_input_term(state, desc[5 + i], &iterm) >= 0) 1753 if (! len && check_input_term(state, desc->baSourceID[i], &iterm) >= 0)
1682 len = get_term_name(state, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0); 1754 len = get_term_name(state, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0);
1683 if (! len) 1755 if (! len)
1684 sprintf(namelist[i], "Input %d", i); 1756 sprintf(namelist[i], "Input %d", i);
@@ -1694,7 +1766,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
1694 kctl->private_value = (unsigned long)namelist; 1766 kctl->private_value = (unsigned long)namelist;
1695 kctl->private_free = usb_mixer_selector_elem_free; 1767 kctl->private_free = usb_mixer_selector_elem_free;
1696 1768
1697 nameid = desc[desc[0] - 1]; 1769 nameid = uac_selector_unit_iSelector(desc);
1698 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name)); 1770 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1699 if (len) 1771 if (len)
1700 ; 1772 ;
@@ -1713,7 +1785,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
1713 } 1785 }
1714 1786
1715 snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n", 1787 snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
1716 cval->id, kctl->id.name, num_ins); 1788 cval->id, kctl->id.name, desc->bNrInPins);
1717 if ((err = add_control_to_empty(state, kctl)) < 0) 1789 if ((err = add_control_to_empty(state, kctl)) < 0)
1718 return err; 1790 return err;
1719 1791
@@ -1748,9 +1820,17 @@ static int parse_audio_unit(struct mixer_build *state, int unitid)
1748 case UAC_FEATURE_UNIT: 1820 case UAC_FEATURE_UNIT:
1749 return parse_audio_feature_unit(state, unitid, p1); 1821 return parse_audio_feature_unit(state, unitid, p1);
1750 case UAC_PROCESSING_UNIT_V1: 1822 case UAC_PROCESSING_UNIT_V1:
1751 return parse_audio_processing_unit(state, unitid, p1); 1823 /* UAC2_EFFECT_UNIT has the same value */
1824 if (state->mixer->protocol == UAC_VERSION_1)
1825 return parse_audio_processing_unit(state, unitid, p1);
1826 else
1827 return 0; /* FIXME - effect units not implemented yet */
1752 case UAC_EXTENSION_UNIT_V1: 1828 case UAC_EXTENSION_UNIT_V1:
1753 return parse_audio_extension_unit(state, unitid, p1); 1829 /* UAC2_PROCESSING_UNIT_V2 has the same value */
1830 if (state->mixer->protocol == UAC_VERSION_1)
1831 return parse_audio_extension_unit(state, unitid, p1);
1832 else /* UAC_VERSION_2 */
1833 return parse_audio_processing_unit(state, unitid, p1);
1754 default: 1834 default:
1755 snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]); 1835 snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
1756 return -EINVAL; 1836 return -EINVAL;
@@ -1783,11 +1863,11 @@ static int snd_usb_mixer_dev_free(struct snd_device *device)
1783 */ 1863 */
1784static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer) 1864static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
1785{ 1865{
1786 struct uac_output_terminal_descriptor_v1 *desc;
1787 struct mixer_build state; 1866 struct mixer_build state;
1788 int err; 1867 int err;
1789 const struct usbmix_ctl_map *map; 1868 const struct usbmix_ctl_map *map;
1790 struct usb_host_interface *hostif; 1869 struct usb_host_interface *hostif;
1870 void *p;
1791 1871
1792 hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0]; 1872 hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
1793 memset(&state, 0, sizeof(state)); 1873 memset(&state, 0, sizeof(state));
@@ -1806,23 +1886,39 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
1806 } 1886 }
1807 } 1887 }
1808 1888
1809 desc = NULL; 1889 p = NULL;
1810 while ((desc = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, desc, UAC_OUTPUT_TERMINAL)) != NULL) { 1890 while ((p = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, p, UAC_OUTPUT_TERMINAL)) != NULL) {
1811 if (desc->bLength < 9) 1891 if (mixer->protocol == UAC_VERSION_1) {
1812 continue; /* invalid descriptor? */ 1892 struct uac_output_terminal_descriptor_v1 *desc = p;
1813 set_bit(desc->bTerminalID, state.unitbitmap); /* mark terminal ID as visited */ 1893
1814 state.oterm.id = desc->bTerminalID; 1894 if (desc->bLength < sizeof(*desc))
1815 state.oterm.type = le16_to_cpu(desc->wTerminalType); 1895 continue; /* invalid descriptor? */
1816 state.oterm.name = desc->iTerminal; 1896 set_bit(desc->bTerminalID, state.unitbitmap); /* mark terminal ID as visited */
1817 err = parse_audio_unit(&state, desc->bSourceID); 1897 state.oterm.id = desc->bTerminalID;
1818 if (err < 0) 1898 state.oterm.type = le16_to_cpu(desc->wTerminalType);
1819 return err; 1899 state.oterm.name = desc->iTerminal;
1900 err = parse_audio_unit(&state, desc->bSourceID);
1901 if (err < 0)
1902 return err;
1903 } else { /* UAC_VERSION_2 */
1904 struct uac2_output_terminal_descriptor *desc = p;
1905
1906 if (desc->bLength < sizeof(*desc))
1907 continue; /* invalid descriptor? */
1908 set_bit(desc->bTerminalID, state.unitbitmap); /* mark terminal ID as visited */
1909 state.oterm.id = desc->bTerminalID;
1910 state.oterm.type = le16_to_cpu(desc->wTerminalType);
1911 state.oterm.name = desc->iTerminal;
1912 err = parse_audio_unit(&state, desc->bSourceID);
1913 if (err < 0)
1914 return err;
1915 }
1820 } 1916 }
1917
1821 return 0; 1918 return 0;
1822} 1919}
1823 1920
1824static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, 1921void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
1825 int unitid)
1826{ 1922{
1827 struct usb_mixer_elem_info *info; 1923 struct usb_mixer_elem_info *info;
1828 1924
@@ -1871,34 +1967,6 @@ static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
1871 } 1967 }
1872} 1968}
1873 1969
1874static void snd_usb_mixer_memory_change(struct usb_mixer_interface *mixer,
1875 int unitid)
1876{
1877 if (!mixer->rc_cfg)
1878 return;
1879 /* unit ids specific to Extigy/Audigy 2 NX: */
1880 switch (unitid) {
1881 case 0: /* remote control */
1882 mixer->rc_urb->dev = mixer->chip->dev;
1883 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
1884 break;
1885 case 4: /* digital in jack */
1886 case 7: /* line in jacks */
1887 case 19: /* speaker out jacks */
1888 case 20: /* headphones out jack */
1889 break;
1890 /* live24ext: 4 = line-in jack */
1891 case 3: /* hp-out jack (may actuate Mute) */
1892 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
1893 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
1894 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
1895 break;
1896 default:
1897 snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
1898 break;
1899 }
1900}
1901
1902static void snd_usb_mixer_status_complete(struct urb *urb) 1970static void snd_usb_mixer_status_complete(struct urb *urb)
1903{ 1971{
1904 struct usb_mixer_interface *mixer = urb->context; 1972 struct usb_mixer_interface *mixer = urb->context;
@@ -1916,7 +1984,7 @@ static void snd_usb_mixer_status_complete(struct urb *urb)
1916 if (!(buf[0] & 0x40)) 1984 if (!(buf[0] & 0x40))
1917 snd_usb_mixer_notify_id(mixer, buf[1]); 1985 snd_usb_mixer_notify_id(mixer, buf[1]);
1918 else 1986 else
1919 snd_usb_mixer_memory_change(mixer, buf[1]); 1987 snd_usb_mixer_rc_memory_change(mixer, buf[1]);
1920 } 1988 }
1921 } 1989 }
1922 if (urb->status != -ENOENT && urb->status != -ECONNRESET) { 1990 if (urb->status != -ENOENT && urb->status != -ECONNRESET) {
@@ -1960,296 +2028,6 @@ static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
1960 return 0; 2028 return 0;
1961} 2029}
1962 2030
1963static void snd_usb_soundblaster_remote_complete(struct urb *urb)
1964{
1965 struct usb_mixer_interface *mixer = urb->context;
1966 const struct rc_config *rc = mixer->rc_cfg;
1967 u32 code;
1968
1969 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
1970 return;
1971
1972 code = mixer->rc_buffer[rc->offset];
1973 if (rc->length == 2)
1974 code |= mixer->rc_buffer[rc->offset + 1] << 8;
1975
1976 /* the Mute button actually changes the mixer control */
1977 if (code == rc->mute_code)
1978 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
1979 mixer->rc_code = code;
1980 wmb();
1981 wake_up(&mixer->rc_waitq);
1982}
1983
1984static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
1985 long count, loff_t *offset)
1986{
1987 struct usb_mixer_interface *mixer = hw->private_data;
1988 int err;
1989 u32 rc_code;
1990
1991 if (count != 1 && count != 4)
1992 return -EINVAL;
1993 err = wait_event_interruptible(mixer->rc_waitq,
1994 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
1995 if (err == 0) {
1996 if (count == 1)
1997 err = put_user(rc_code, buf);
1998 else
1999 err = put_user(rc_code, (u32 __user *)buf);
2000 }
2001 return err < 0 ? err : count;
2002}
2003
2004static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
2005 poll_table *wait)
2006{
2007 struct usb_mixer_interface *mixer = hw->private_data;
2008
2009 poll_wait(file, &mixer->rc_waitq, wait);
2010 return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
2011}
2012
2013static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
2014{
2015 struct snd_hwdep *hwdep;
2016 int err, len, i;
2017
2018 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
2019 if (rc_configs[i].usb_id == mixer->chip->usb_id)
2020 break;
2021 if (i >= ARRAY_SIZE(rc_configs))
2022 return 0;
2023 mixer->rc_cfg = &rc_configs[i];
2024
2025 len = mixer->rc_cfg->packet_length;
2026
2027 init_waitqueue_head(&mixer->rc_waitq);
2028 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
2029 if (err < 0)
2030 return err;
2031 snprintf(hwdep->name, sizeof(hwdep->name),
2032 "%s remote control", mixer->chip->card->shortname);
2033 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
2034 hwdep->private_data = mixer;
2035 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
2036 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
2037 hwdep->exclusive = 1;
2038
2039 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
2040 if (!mixer->rc_urb)
2041 return -ENOMEM;
2042 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
2043 if (!mixer->rc_setup_packet) {
2044 usb_free_urb(mixer->rc_urb);
2045 mixer->rc_urb = NULL;
2046 return -ENOMEM;
2047 }
2048 mixer->rc_setup_packet->bRequestType =
2049 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
2050 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
2051 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
2052 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
2053 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
2054 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
2055 usb_rcvctrlpipe(mixer->chip->dev, 0),
2056 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
2057 snd_usb_soundblaster_remote_complete, mixer);
2058 return 0;
2059}
2060
2061#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
2062
2063static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2064{
2065 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
2066 int index = kcontrol->private_value;
2067
2068 ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
2069 return 0;
2070}
2071
2072static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2073{
2074 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
2075 int index = kcontrol->private_value;
2076 int value = ucontrol->value.integer.value[0];
2077 int err, changed;
2078
2079 if (value > 1)
2080 return -EINVAL;
2081 changed = value != mixer->audigy2nx_leds[index];
2082 err = snd_usb_ctl_msg(mixer->chip->dev,
2083 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
2084 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
2085 value, index + 2, NULL, 0, 100);
2086 if (err < 0)
2087 return err;
2088 mixer->audigy2nx_leds[index] = value;
2089 return changed;
2090}
2091
2092static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
2093 {
2094 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2095 .name = "CMSS LED Switch",
2096 .info = snd_audigy2nx_led_info,
2097 .get = snd_audigy2nx_led_get,
2098 .put = snd_audigy2nx_led_put,
2099 .private_value = 0,
2100 },
2101 {
2102 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2103 .name = "Power LED Switch",
2104 .info = snd_audigy2nx_led_info,
2105 .get = snd_audigy2nx_led_get,
2106 .put = snd_audigy2nx_led_put,
2107 .private_value = 1,
2108 },
2109 {
2110 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2111 .name = "Dolby Digital LED Switch",
2112 .info = snd_audigy2nx_led_info,
2113 .get = snd_audigy2nx_led_get,
2114 .put = snd_audigy2nx_led_put,
2115 .private_value = 2,
2116 },
2117};
2118
2119static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
2120{
2121 int i, err;
2122
2123 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
2124 if (i > 1 && /* Live24ext has 2 LEDs only */
2125 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
2126 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
2127 break;
2128 err = snd_ctl_add(mixer->chip->card,
2129 snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
2130 if (err < 0)
2131 return err;
2132 }
2133 mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
2134 return 0;
2135}
2136
2137static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
2138 struct snd_info_buffer *buffer)
2139{
2140 static const struct sb_jack {
2141 int unitid;
2142 const char *name;
2143 } jacks_audigy2nx[] = {
2144 {4, "dig in "},
2145 {7, "line in"},
2146 {19, "spk out"},
2147 {20, "hph out"},
2148 {-1, NULL}
2149 }, jacks_live24ext[] = {
2150 {4, "line in"}, /* &1=Line, &2=Mic*/
2151 {3, "hph out"}, /* headphones */
2152 {0, "RC "}, /* last command, 6 bytes see rc_config above */
2153 {-1, NULL}
2154 };
2155 const struct sb_jack *jacks;
2156 struct usb_mixer_interface *mixer = entry->private_data;
2157 int i, err;
2158 u8 buf[3];
2159
2160 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
2161 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
2162 jacks = jacks_audigy2nx;
2163 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
2164 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
2165 jacks = jacks_live24ext;
2166 else
2167 return;
2168
2169 for (i = 0; jacks[i].name; ++i) {
2170 snd_iprintf(buffer, "%s: ", jacks[i].name);
2171 err = snd_usb_ctl_msg(mixer->chip->dev,
2172 usb_rcvctrlpipe(mixer->chip->dev, 0),
2173 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
2174 USB_RECIP_INTERFACE, 0,
2175 jacks[i].unitid << 8, buf, 3, 100);
2176 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
2177 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
2178 else
2179 snd_iprintf(buffer, "?\n");
2180 }
2181}
2182
2183static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
2184 struct snd_ctl_elem_value *ucontrol)
2185{
2186 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
2187
2188 ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
2189 return 0;
2190}
2191
2192static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
2193 struct snd_ctl_elem_value *ucontrol)
2194{
2195 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
2196 u8 old_status, new_status;
2197 int err, changed;
2198
2199 old_status = mixer->xonar_u1_status;
2200 if (ucontrol->value.integer.value[0])
2201 new_status = old_status | 0x02;
2202 else
2203 new_status = old_status & ~0x02;
2204 changed = new_status != old_status;
2205 err = snd_usb_ctl_msg(mixer->chip->dev,
2206 usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
2207 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
2208 50, 0, &new_status, 1, 100);
2209 if (err < 0)
2210 return err;
2211 mixer->xonar_u1_status = new_status;
2212 return changed;
2213}
2214
2215static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
2216 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2217 .name = "Digital Playback Switch",
2218 .info = snd_ctl_boolean_mono_info,
2219 .get = snd_xonar_u1_switch_get,
2220 .put = snd_xonar_u1_switch_put,
2221};
2222
2223static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
2224{
2225 int err;
2226
2227 err = snd_ctl_add(mixer->chip->card,
2228 snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
2229 if (err < 0)
2230 return err;
2231 mixer->xonar_u1_status = 0x05;
2232 return 0;
2233}
2234
2235void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
2236 unsigned char samplerate_id)
2237{
2238 struct usb_mixer_interface *mixer;
2239 struct usb_mixer_elem_info *cval;
2240 int unitid = 12; /* SamleRate ExtensionUnit ID */
2241
2242 list_for_each_entry(mixer, &chip->mixer_list, list) {
2243 cval = mixer->id_elems[unitid];
2244 if (cval) {
2245 set_cur_ctl_value(cval, cval->control << 8,
2246 samplerate_id);
2247 snd_usb_mixer_notify_id(mixer, unitid);
2248 }
2249 break;
2250 }
2251}
2252
2253int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif, 2031int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
2254 int ignore_error) 2032 int ignore_error)
2255{ 2033{
@@ -2259,7 +2037,7 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
2259 struct usb_mixer_interface *mixer; 2037 struct usb_mixer_interface *mixer;
2260 struct snd_info_entry *entry; 2038 struct snd_info_entry *entry;
2261 struct usb_host_interface *host_iface; 2039 struct usb_host_interface *host_iface;
2262 int err, protocol; 2040 int err;
2263 2041
2264 strcpy(chip->card->mixername, "USB Mixer"); 2042 strcpy(chip->card->mixername, "USB Mixer");
2265 2043
@@ -2277,38 +2055,13 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
2277 } 2055 }
2278 2056
2279 host_iface = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0]; 2057 host_iface = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
2280 protocol = host_iface->desc.bInterfaceProtocol; 2058 mixer->protocol = host_iface->desc.bInterfaceProtocol;
2281
2282 /* FIXME! */
2283 if (protocol != UAC_VERSION_1) {
2284 snd_printk(KERN_WARNING "mixer interface protocol 0x%02x not yet supported\n",
2285 protocol);
2286 return 0;
2287 }
2288 2059
2289 if ((err = snd_usb_mixer_controls(mixer)) < 0 || 2060 if ((err = snd_usb_mixer_controls(mixer)) < 0 ||
2290 (err = snd_usb_mixer_status_create(mixer)) < 0) 2061 (err = snd_usb_mixer_status_create(mixer)) < 0)
2291 goto _error; 2062 goto _error;
2292 2063
2293 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0) 2064 snd_usb_mixer_apply_create_quirk(mixer);
2294 goto _error;
2295
2296 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
2297 mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
2298 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
2299 if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
2300 goto _error;
2301 if (!snd_card_proc_new(chip->card, "audigy2nx", &entry))
2302 snd_info_set_text_ops(entry, mixer,
2303 snd_audigy2nx_proc_read);
2304 }
2305
2306 if (mixer->chip->usb_id == USB_ID(0x0b05, 0x1739) ||
2307 mixer->chip->usb_id == USB_ID(0x0b05, 0x1743)) {
2308 err = snd_xonar_u1_controls_create(mixer);
2309 if (err < 0)
2310 goto _error;
2311 }
2312 2065
2313 err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops); 2066 err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
2314 if (err < 0) 2067 if (err < 0)
@@ -2329,7 +2082,7 @@ _error:
2329void snd_usb_mixer_disconnect(struct list_head *p) 2082void snd_usb_mixer_disconnect(struct list_head *p)
2330{ 2083{
2331 struct usb_mixer_interface *mixer; 2084 struct usb_mixer_interface *mixer;
2332 2085
2333 mixer = list_entry(p, struct usb_mixer_interface, list); 2086 mixer = list_entry(p, struct usb_mixer_interface, list);
2334 usb_kill_urb(mixer->urb); 2087 usb_kill_urb(mixer->urb);
2335 usb_kill_urb(mixer->rc_urb); 2088 usb_kill_urb(mixer->rc_urb);
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
new file mode 100644
index 000000000000..130123854a6c
--- /dev/null
+++ b/sound/usb/mixer.h
@@ -0,0 +1,55 @@
1#ifndef __USBMIXER_H
2#define __USBMIXER_H
3
4struct usb_mixer_interface {
5 struct snd_usb_audio *chip;
6 unsigned int ctrlif;
7 struct list_head list;
8 unsigned int ignore_ctl_error;
9 struct urb *urb;
10 /* array[MAX_ID_ELEMS], indexed by unit id */
11 struct usb_mixer_elem_info **id_elems;
12
13 /* the usb audio specification version this interface complies to */
14 int protocol;
15
16 /* Sound Blaster remote control stuff */
17 const struct rc_config *rc_cfg;
18 u32 rc_code;
19 wait_queue_head_t rc_waitq;
20 struct urb *rc_urb;
21 struct usb_ctrlrequest *rc_setup_packet;
22 u8 rc_buffer[6];
23
24 u8 audigy2nx_leds[3];
25 u8 xonar_u1_status;
26};
27
28#define MAX_CHANNELS 10 /* max logical channels */
29
30struct usb_mixer_elem_info {
31 struct usb_mixer_interface *mixer;
32 struct usb_mixer_elem_info *next_id_elem; /* list of controls with same id */
33 struct snd_ctl_elem_id *elem_id;
34 unsigned int id;
35 unsigned int control; /* CS or ICN (high byte) */
36 unsigned int cmask; /* channel mask bitmap: 0 = master */
37 int channels;
38 int val_type;
39 int min, max, res;
40 int dBmin, dBmax;
41 int cached;
42 int cache_val[MAX_CHANNELS];
43 u8 initialized;
44};
45
46int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
47 int ignore_error);
48void snd_usb_mixer_disconnect(struct list_head *p);
49
50void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid);
51
52int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
53 int request, int validx, int value_set);
54
55#endif /* __USBMIXER_H */
diff --git a/sound/usb/usbmixer_maps.c b/sound/usb/mixer_maps.c
index 79e903a60862..d93fc89beba8 100644
--- a/sound/usb/usbmixer_maps.c
+++ b/sound/usb/mixer_maps.c
@@ -85,8 +85,8 @@ static struct usbmix_name_map extigy_map[] = {
85 /* 16: MU (w/o controls) */ 85 /* 16: MU (w/o controls) */
86 { 17, NULL, 1 }, /* DISABLED: PU-switch (any effect?) */ 86 { 17, NULL, 1 }, /* DISABLED: PU-switch (any effect?) */
87 { 17, "Channel Routing", 2 }, /* PU: mode select */ 87 { 17, "Channel Routing", 2 }, /* PU: mode select */
88 { 18, "Tone Control - Bass", USB_FEATURE_BASS }, /* FU */ 88 { 18, "Tone Control - Bass", UAC_BASS_CONTROL }, /* FU */
89 { 18, "Tone Control - Treble", USB_FEATURE_TREBLE }, /* FU */ 89 { 18, "Tone Control - Treble", UAC_TREBLE_CONTROL }, /* FU */
90 { 18, "Master Playback" }, /* FU; others */ 90 { 18, "Master Playback" }, /* FU; others */
91 /* 19: OT speaker */ 91 /* 19: OT speaker */
92 /* 20: OT headphone */ 92 /* 20: OT headphone */
diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
new file mode 100644
index 000000000000..e7df1e5e3f2e
--- /dev/null
+++ b/sound/usb/mixer_quirks.c
@@ -0,0 +1,412 @@
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/*
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 */
63 { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
64};
65
66static void snd_usb_soundblaster_remote_complete(struct urb *urb)
67{
68 struct usb_mixer_interface *mixer = urb->context;
69 const struct rc_config *rc = mixer->rc_cfg;
70 u32 code;
71
72 if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
73 return;
74
75 code = mixer->rc_buffer[rc->offset];
76 if (rc->length == 2)
77 code |= mixer->rc_buffer[rc->offset + 1] << 8;
78
79 /* the Mute button actually changes the mixer control */
80 if (code == rc->mute_code)
81 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
82 mixer->rc_code = code;
83 wmb();
84 wake_up(&mixer->rc_waitq);
85}
86
87static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
88 long count, loff_t *offset)
89{
90 struct usb_mixer_interface *mixer = hw->private_data;
91 int err;
92 u32 rc_code;
93
94 if (count != 1 && count != 4)
95 return -EINVAL;
96 err = wait_event_interruptible(mixer->rc_waitq,
97 (rc_code = xchg(&mixer->rc_code, 0)) != 0);
98 if (err == 0) {
99 if (count == 1)
100 err = put_user(rc_code, buf);
101 else
102 err = put_user(rc_code, (u32 __user *)buf);
103 }
104 return err < 0 ? err : count;
105}
106
107static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
108 poll_table *wait)
109{
110 struct usb_mixer_interface *mixer = hw->private_data;
111
112 poll_wait(file, &mixer->rc_waitq, wait);
113 return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
114}
115
116static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
117{
118 struct snd_hwdep *hwdep;
119 int err, len, i;
120
121 for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
122 if (rc_configs[i].usb_id == mixer->chip->usb_id)
123 break;
124 if (i >= ARRAY_SIZE(rc_configs))
125 return 0;
126 mixer->rc_cfg = &rc_configs[i];
127
128 len = mixer->rc_cfg->packet_length;
129
130 init_waitqueue_head(&mixer->rc_waitq);
131 err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
132 if (err < 0)
133 return err;
134 snprintf(hwdep->name, sizeof(hwdep->name),
135 "%s remote control", mixer->chip->card->shortname);
136 hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
137 hwdep->private_data = mixer;
138 hwdep->ops.read = snd_usb_sbrc_hwdep_read;
139 hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
140 hwdep->exclusive = 1;
141
142 mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
143 if (!mixer->rc_urb)
144 return -ENOMEM;
145 mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
146 if (!mixer->rc_setup_packet) {
147 usb_free_urb(mixer->rc_urb);
148 mixer->rc_urb = NULL;
149 return -ENOMEM;
150 }
151 mixer->rc_setup_packet->bRequestType =
152 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
153 mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
154 mixer->rc_setup_packet->wValue = cpu_to_le16(0);
155 mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
156 mixer->rc_setup_packet->wLength = cpu_to_le16(len);
157 usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
158 usb_rcvctrlpipe(mixer->chip->dev, 0),
159 (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
160 snd_usb_soundblaster_remote_complete, mixer);
161 return 0;
162}
163
164#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
165
166static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
167{
168 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
169 int index = kcontrol->private_value;
170
171 ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
172 return 0;
173}
174
175static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
176{
177 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
178 int index = kcontrol->private_value;
179 int value = ucontrol->value.integer.value[0];
180 int err, changed;
181
182 if (value > 1)
183 return -EINVAL;
184 changed = value != mixer->audigy2nx_leds[index];
185 err = snd_usb_ctl_msg(mixer->chip->dev,
186 usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
187 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
188 value, index + 2, NULL, 0, 100);
189 if (err < 0)
190 return err;
191 mixer->audigy2nx_leds[index] = value;
192 return changed;
193}
194
195static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
196 {
197 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
198 .name = "CMSS LED Switch",
199 .info = snd_audigy2nx_led_info,
200 .get = snd_audigy2nx_led_get,
201 .put = snd_audigy2nx_led_put,
202 .private_value = 0,
203 },
204 {
205 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
206 .name = "Power LED Switch",
207 .info = snd_audigy2nx_led_info,
208 .get = snd_audigy2nx_led_get,
209 .put = snd_audigy2nx_led_put,
210 .private_value = 1,
211 },
212 {
213 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
214 .name = "Dolby Digital LED Switch",
215 .info = snd_audigy2nx_led_info,
216 .get = snd_audigy2nx_led_get,
217 .put = snd_audigy2nx_led_put,
218 .private_value = 2,
219 },
220};
221
222static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
223{
224 int i, err;
225
226 for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
227 if (i > 1 && /* Live24ext has 2 LEDs only */
228 (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
229 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
230 break;
231 err = snd_ctl_add(mixer->chip->card,
232 snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
233 if (err < 0)
234 return err;
235 }
236 mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
237 return 0;
238}
239
240static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
241 struct snd_info_buffer *buffer)
242{
243 static const struct sb_jack {
244 int unitid;
245 const char *name;
246 } jacks_audigy2nx[] = {
247 {4, "dig in "},
248 {7, "line in"},
249 {19, "spk out"},
250 {20, "hph out"},
251 {-1, NULL}
252 }, jacks_live24ext[] = {
253 {4, "line in"}, /* &1=Line, &2=Mic*/
254 {3, "hph out"}, /* headphones */
255 {0, "RC "}, /* last command, 6 bytes see rc_config above */
256 {-1, NULL}
257 };
258 const struct sb_jack *jacks;
259 struct usb_mixer_interface *mixer = entry->private_data;
260 int i, err;
261 u8 buf[3];
262
263 snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
264 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
265 jacks = jacks_audigy2nx;
266 else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
267 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
268 jacks = jacks_live24ext;
269 else
270 return;
271
272 for (i = 0; jacks[i].name; ++i) {
273 snd_iprintf(buffer, "%s: ", jacks[i].name);
274 err = snd_usb_ctl_msg(mixer->chip->dev,
275 usb_rcvctrlpipe(mixer->chip->dev, 0),
276 UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
277 USB_RECIP_INTERFACE, 0,
278 jacks[i].unitid << 8, buf, 3, 100);
279 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
280 snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
281 else
282 snd_iprintf(buffer, "?\n");
283 }
284}
285
286static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
287 struct snd_ctl_elem_value *ucontrol)
288{
289 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
290
291 ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
292 return 0;
293}
294
295static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
296 struct snd_ctl_elem_value *ucontrol)
297{
298 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
299 u8 old_status, new_status;
300 int err, changed;
301
302 old_status = mixer->xonar_u1_status;
303 if (ucontrol->value.integer.value[0])
304 new_status = old_status | 0x02;
305 else
306 new_status = old_status & ~0x02;
307 changed = new_status != old_status;
308 err = snd_usb_ctl_msg(mixer->chip->dev,
309 usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
310 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
311 50, 0, &new_status, 1, 100);
312 if (err < 0)
313 return err;
314 mixer->xonar_u1_status = new_status;
315 return changed;
316}
317
318static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
319 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
320 .name = "Digital Playback Switch",
321 .info = snd_ctl_boolean_mono_info,
322 .get = snd_xonar_u1_switch_get,
323 .put = snd_xonar_u1_switch_put,
324};
325
326static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
327{
328 int err;
329
330 err = snd_ctl_add(mixer->chip->card,
331 snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
332 if (err < 0)
333 return err;
334 mixer->xonar_u1_status = 0x05;
335 return 0;
336}
337
338void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
339 unsigned char samplerate_id)
340{
341 struct usb_mixer_interface *mixer;
342 struct usb_mixer_elem_info *cval;
343 int unitid = 12; /* SamleRate ExtensionUnit ID */
344
345 list_for_each_entry(mixer, &chip->mixer_list, list) {
346 cval = mixer->id_elems[unitid];
347 if (cval) {
348 snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
349 cval->control << 8,
350 samplerate_id);
351 snd_usb_mixer_notify_id(mixer, unitid);
352 }
353 break;
354 }
355}
356
357int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
358{
359 int err;
360 struct snd_info_entry *entry;
361
362 if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
363 return err;
364
365 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
366 mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
367 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
368 if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
369 return err;
370 if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
371 snd_info_set_text_ops(entry, mixer,
372 snd_audigy2nx_proc_read);
373 }
374
375 if (mixer->chip->usb_id == USB_ID(0x0b05, 0x1739) ||
376 mixer->chip->usb_id == USB_ID(0x0b05, 0x1743)) {
377 err = snd_xonar_u1_controls_create(mixer);
378 if (err < 0)
379 return err;
380 }
381
382 return 0;
383}
384
385void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
386 int unitid)
387{
388 if (!mixer->rc_cfg)
389 return;
390 /* unit ids specific to Extigy/Audigy 2 NX: */
391 switch (unitid) {
392 case 0: /* remote control */
393 mixer->rc_urb->dev = mixer->chip->dev;
394 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
395 break;
396 case 4: /* digital in jack */
397 case 7: /* line in jacks */
398 case 19: /* speaker out jacks */
399 case 20: /* headphones out jack */
400 break;
401 /* live24ext: 4 = line-in jack */
402 case 3: /* hp-out jack (may actuate Mute) */
403 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
404 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
405 snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
406 break;
407 default:
408 snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
409 break;
410 }
411}
412
diff --git a/sound/usb/mixer_quirks.h b/sound/usb/mixer_quirks.h
new file mode 100644
index 000000000000..bdbfab093816
--- /dev/null
+++ b/sound/usb/mixer_quirks.h
@@ -0,0 +1,13 @@
1#ifndef SND_USB_MIXER_QUIRKS_H
2#define SND_USB_MIXER_QUIRKS_H
3
4int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer);
5
6void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
7 unsigned char samplerate_id);
8
9void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
10 int unitid);
11
12#endif /* SND_USB_MIXER_QUIRKS_H */
13
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
new file mode 100644
index 000000000000..2bf0d77d1768
--- /dev/null
+++ b/sound/usb/pcm.c
@@ -0,0 +1,935 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17#include <linux/init.h>
18#include <linux/slab.h>
19#include <linux/usb.h>
20#include <linux/usb/audio.h>
21#include <linux/usb/audio-v2.h>
22
23#include <sound/core.h>
24#include <sound/pcm.h>
25#include <sound/pcm_params.h>
26
27#include "usbaudio.h"
28#include "card.h"
29#include "quirks.h"
30#include "debug.h"
31#include "urb.h"
32#include "helper.h"
33#include "pcm.h"
34
35/*
36 * return the current pcm pointer. just based on the hwptr_done value.
37 */
38static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
39{
40 struct snd_usb_substream *subs;
41 unsigned int hwptr_done;
42
43 subs = (struct snd_usb_substream *)substream->runtime->private_data;
44 spin_lock(&subs->lock);
45 hwptr_done = subs->hwptr_done;
46 spin_unlock(&subs->lock);
47 return hwptr_done / (substream->runtime->frame_bits >> 3);
48}
49
50/*
51 * find a matching audio format
52 */
53static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format,
54 unsigned int rate, unsigned int channels)
55{
56 struct list_head *p;
57 struct audioformat *found = NULL;
58 int cur_attr = 0, attr;
59
60 list_for_each(p, &subs->fmt_list) {
61 struct audioformat *fp;
62 fp = list_entry(p, struct audioformat, list);
63 if (!(fp->formats & (1uLL << format)))
64 continue;
65 if (fp->channels != channels)
66 continue;
67 if (rate < fp->rate_min || rate > fp->rate_max)
68 continue;
69 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
70 unsigned int i;
71 for (i = 0; i < fp->nr_rates; i++)
72 if (fp->rate_table[i] == rate)
73 break;
74 if (i >= fp->nr_rates)
75 continue;
76 }
77 attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
78 if (! found) {
79 found = fp;
80 cur_attr = attr;
81 continue;
82 }
83 /* avoid async out and adaptive in if the other method
84 * supports the same format.
85 * this is a workaround for the case like
86 * M-audio audiophile USB.
87 */
88 if (attr != cur_attr) {
89 if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
90 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
91 (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
92 subs->direction == SNDRV_PCM_STREAM_CAPTURE))
93 continue;
94 if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
95 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
96 (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
97 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
98 found = fp;
99 cur_attr = attr;
100 continue;
101 }
102 }
103 /* find the format with the largest max. packet size */
104 if (fp->maxpacksize > found->maxpacksize) {
105 found = fp;
106 cur_attr = attr;
107 }
108 }
109 return found;
110}
111
112static int init_pitch_v1(struct snd_usb_audio *chip, int iface,
113 struct usb_host_interface *alts,
114 struct audioformat *fmt)
115{
116 struct usb_device *dev = chip->dev;
117 unsigned int ep;
118 unsigned char data[1];
119 int err;
120
121 ep = get_endpoint(alts, 0)->bEndpointAddress;
122
123 /* if endpoint doesn't have pitch control, bail out */
124 if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL))
125 return 0;
126
127 data[0] = 1;
128 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
129 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
130 UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep,
131 data, sizeof(data), 1000)) < 0) {
132 snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
133 dev->devnum, iface, ep);
134 return err;
135 }
136
137 return 0;
138}
139
140/*
141 * initialize the picth control and sample rate
142 */
143int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
144 struct usb_host_interface *alts,
145 struct audioformat *fmt)
146{
147 struct usb_interface_descriptor *altsd = get_iface_desc(alts);
148
149 switch (altsd->bInterfaceProtocol) {
150 case UAC_VERSION_1:
151 return init_pitch_v1(chip, iface, alts, fmt);
152
153 case UAC_VERSION_2:
154 /* not implemented yet */
155 return 0;
156 }
157
158 return -EINVAL;
159}
160
161static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
162 struct usb_host_interface *alts,
163 struct audioformat *fmt, int rate)
164{
165 struct usb_device *dev = chip->dev;
166 unsigned int ep;
167 unsigned char data[3];
168 int err, crate;
169
170 ep = get_endpoint(alts, 0)->bEndpointAddress;
171 /* if endpoint doesn't have sampling rate control, bail out */
172 if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE)) {
173 snd_printk(KERN_WARNING "%d:%d:%d: endpoint lacks sample rate attribute bit, cannot set.\n",
174 dev->devnum, iface, fmt->altsetting);
175 return 0;
176 }
177
178 data[0] = rate;
179 data[1] = rate >> 8;
180 data[2] = rate >> 16;
181 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
182 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
183 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
184 data, sizeof(data), 1000)) < 0) {
185 snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
186 dev->devnum, iface, fmt->altsetting, rate, ep);
187 return err;
188 }
189 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
190 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
191 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
192 data, sizeof(data), 1000)) < 0) {
193 snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
194 dev->devnum, iface, fmt->altsetting, ep);
195 return 0; /* some devices don't support reading */
196 }
197 crate = data[0] | (data[1] << 8) | (data[2] << 16);
198 if (crate != rate) {
199 snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
200 // runtime->rate = crate;
201 }
202
203 return 0;
204}
205
206static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface,
207 struct usb_host_interface *alts,
208 struct audioformat *fmt, int rate)
209{
210 struct usb_device *dev = chip->dev;
211 unsigned char data[4];
212 int err, crate;
213
214 data[0] = rate;
215 data[1] = rate >> 8;
216 data[2] = rate >> 16;
217 data[3] = rate >> 24;
218 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
219 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
220 UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
221 data, sizeof(data), 1000)) < 0) {
222 snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d (v2)\n",
223 dev->devnum, iface, fmt->altsetting, rate);
224 return err;
225 }
226 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
227 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
228 UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
229 data, sizeof(data), 1000)) < 0) {
230 snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq (v2)\n",
231 dev->devnum, iface, fmt->altsetting);
232 return err;
233 }
234 crate = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
235 if (crate != rate)
236 snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
237
238 return 0;
239}
240
241int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
242 struct usb_host_interface *alts,
243 struct audioformat *fmt, int rate)
244{
245 struct usb_interface_descriptor *altsd = get_iface_desc(alts);
246
247 switch (altsd->bInterfaceProtocol) {
248 case UAC_VERSION_1:
249 return set_sample_rate_v1(chip, iface, alts, fmt, rate);
250
251 case UAC_VERSION_2:
252 return set_sample_rate_v2(chip, iface, alts, fmt, rate);
253 }
254
255 return -EINVAL;
256}
257
258/*
259 * find a matching format and set up the interface
260 */
261static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
262{
263 struct usb_device *dev = subs->dev;
264 struct usb_host_interface *alts;
265 struct usb_interface_descriptor *altsd;
266 struct usb_interface *iface;
267 unsigned int ep, attr;
268 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
269 int err;
270
271 iface = usb_ifnum_to_if(dev, fmt->iface);
272 if (WARN_ON(!iface))
273 return -EINVAL;
274 alts = &iface->altsetting[fmt->altset_idx];
275 altsd = get_iface_desc(alts);
276 if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
277 return -EINVAL;
278
279 if (fmt == subs->cur_audiofmt)
280 return 0;
281
282 /* close the old interface */
283 if (subs->interface >= 0 && subs->interface != fmt->iface) {
284 if (usb_set_interface(subs->dev, subs->interface, 0) < 0) {
285 snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed\n",
286 dev->devnum, fmt->iface, fmt->altsetting);
287 return -EIO;
288 }
289 subs->interface = -1;
290 subs->altset_idx = 0;
291 }
292
293 /* set interface */
294 if (subs->interface != fmt->iface || subs->altset_idx != fmt->altset_idx) {
295 if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
296 snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
297 dev->devnum, fmt->iface, fmt->altsetting);
298 return -EIO;
299 }
300 snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
301 subs->interface = fmt->iface;
302 subs->altset_idx = fmt->altset_idx;
303 }
304
305 /* create a data pipe */
306 ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
307 if (is_playback)
308 subs->datapipe = usb_sndisocpipe(dev, ep);
309 else
310 subs->datapipe = usb_rcvisocpipe(dev, ep);
311 subs->datainterval = fmt->datainterval;
312 subs->syncpipe = subs->syncinterval = 0;
313 subs->maxpacksize = fmt->maxpacksize;
314 subs->fill_max = 0;
315
316 /* we need a sync pipe in async OUT or adaptive IN mode */
317 /* check the number of EP, since some devices have broken
318 * descriptors which fool us. if it has only one EP,
319 * assume it as adaptive-out or sync-in.
320 */
321 attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
322 if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) ||
323 (! is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
324 altsd->bNumEndpoints >= 2) {
325 /* check sync-pipe endpoint */
326 /* ... and check descriptor size before accessing bSynchAddress
327 because there is a version of the SB Audigy 2 NX firmware lacking
328 the audio fields in the endpoint descriptors */
329 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
330 (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
331 get_endpoint(alts, 1)->bSynchAddress != 0)) {
332 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
333 dev->devnum, fmt->iface, fmt->altsetting);
334 return -EINVAL;
335 }
336 ep = get_endpoint(alts, 1)->bEndpointAddress;
337 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
338 (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
339 (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
340 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
341 dev->devnum, fmt->iface, fmt->altsetting);
342 return -EINVAL;
343 }
344 ep &= USB_ENDPOINT_NUMBER_MASK;
345 if (is_playback)
346 subs->syncpipe = usb_rcvisocpipe(dev, ep);
347 else
348 subs->syncpipe = usb_sndisocpipe(dev, ep);
349 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
350 get_endpoint(alts, 1)->bRefresh >= 1 &&
351 get_endpoint(alts, 1)->bRefresh <= 9)
352 subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
353 else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
354 subs->syncinterval = 1;
355 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
356 get_endpoint(alts, 1)->bInterval <= 16)
357 subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
358 else
359 subs->syncinterval = 3;
360 }
361
362 /* always fill max packet size */
363 if (fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX)
364 subs->fill_max = 1;
365
366 if ((err = snd_usb_init_pitch(subs->stream->chip, subs->interface, alts, fmt)) < 0)
367 return err;
368
369 subs->cur_audiofmt = fmt;
370
371 snd_usb_set_format_quirk(subs, fmt);
372
373#if 0
374 printk(KERN_DEBUG
375 "setting done: format = %d, rate = %d..%d, channels = %d\n",
376 fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels);
377 printk(KERN_DEBUG
378 " datapipe = 0x%0x, syncpipe = 0x%0x\n",
379 subs->datapipe, subs->syncpipe);
380#endif
381
382 return 0;
383}
384
385/*
386 * hw_params callback
387 *
388 * allocate a buffer and set the given audio format.
389 *
390 * so far we use a physically linear buffer although packetize transfer
391 * doesn't need a continuous area.
392 * if sg buffer is supported on the later version of alsa, we'll follow
393 * that.
394 */
395static int snd_usb_hw_params(struct snd_pcm_substream *substream,
396 struct snd_pcm_hw_params *hw_params)
397{
398 struct snd_usb_substream *subs = substream->runtime->private_data;
399 struct audioformat *fmt;
400 unsigned int channels, rate, format;
401 int ret, changed;
402
403 ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
404 params_buffer_bytes(hw_params));
405 if (ret < 0)
406 return ret;
407
408 format = params_format(hw_params);
409 rate = params_rate(hw_params);
410 channels = params_channels(hw_params);
411 fmt = find_format(subs, format, rate, channels);
412 if (!fmt) {
413 snd_printd(KERN_DEBUG "cannot set format: format = %#x, rate = %d, channels = %d\n",
414 format, rate, channels);
415 return -EINVAL;
416 }
417
418 changed = subs->cur_audiofmt != fmt ||
419 subs->period_bytes != params_period_bytes(hw_params) ||
420 subs->cur_rate != rate;
421 if ((ret = set_format(subs, fmt)) < 0)
422 return ret;
423
424 if (subs->cur_rate != rate) {
425 struct usb_host_interface *alts;
426 struct usb_interface *iface;
427 iface = usb_ifnum_to_if(subs->dev, fmt->iface);
428 alts = &iface->altsetting[fmt->altset_idx];
429 ret = snd_usb_init_sample_rate(subs->stream->chip, subs->interface, alts, fmt, rate);
430 if (ret < 0)
431 return ret;
432 subs->cur_rate = rate;
433 }
434
435 if (changed) {
436 /* format changed */
437 snd_usb_release_substream_urbs(subs, 0);
438 /* influenced: period_bytes, channels, rate, format, */
439 ret = snd_usb_init_substream_urbs(subs, params_period_bytes(hw_params),
440 params_rate(hw_params),
441 snd_pcm_format_physical_width(params_format(hw_params)) *
442 params_channels(hw_params));
443 }
444
445 return ret;
446}
447
448/*
449 * hw_free callback
450 *
451 * reset the audio format and release the buffer
452 */
453static int snd_usb_hw_free(struct snd_pcm_substream *substream)
454{
455 struct snd_usb_substream *subs = substream->runtime->private_data;
456
457 subs->cur_audiofmt = NULL;
458 subs->cur_rate = 0;
459 subs->period_bytes = 0;
460 if (!subs->stream->chip->shutdown)
461 snd_usb_release_substream_urbs(subs, 0);
462 return snd_pcm_lib_free_vmalloc_buffer(substream);
463}
464
465/*
466 * prepare callback
467 *
468 * only a few subtle things...
469 */
470static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
471{
472 struct snd_pcm_runtime *runtime = substream->runtime;
473 struct snd_usb_substream *subs = runtime->private_data;
474
475 if (! subs->cur_audiofmt) {
476 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
477 return -ENXIO;
478 }
479
480 /* some unit conversions in runtime */
481 subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
482 subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
483
484 /* reset the pointer */
485 subs->hwptr_done = 0;
486 subs->transfer_done = 0;
487 subs->phase = 0;
488 runtime->delay = 0;
489
490 return snd_usb_substream_prepare(subs, runtime);
491}
492
493static struct snd_pcm_hardware snd_usb_hardware =
494{
495 .info = SNDRV_PCM_INFO_MMAP |
496 SNDRV_PCM_INFO_MMAP_VALID |
497 SNDRV_PCM_INFO_BATCH |
498 SNDRV_PCM_INFO_INTERLEAVED |
499 SNDRV_PCM_INFO_BLOCK_TRANSFER |
500 SNDRV_PCM_INFO_PAUSE,
501 .buffer_bytes_max = 1024 * 1024,
502 .period_bytes_min = 64,
503 .period_bytes_max = 512 * 1024,
504 .periods_min = 2,
505 .periods_max = 1024,
506};
507
508static int hw_check_valid_format(struct snd_usb_substream *subs,
509 struct snd_pcm_hw_params *params,
510 struct audioformat *fp)
511{
512 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
513 struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
514 struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
515 struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
516 struct snd_mask check_fmts;
517 unsigned int ptime;
518
519 /* check the format */
520 snd_mask_none(&check_fmts);
521 check_fmts.bits[0] = (u32)fp->formats;
522 check_fmts.bits[1] = (u32)(fp->formats >> 32);
523 snd_mask_intersect(&check_fmts, fmts);
524 if (snd_mask_empty(&check_fmts)) {
525 hwc_debug(" > check: no supported format %d\n", fp->format);
526 return 0;
527 }
528 /* check the channels */
529 if (fp->channels < ct->min || fp->channels > ct->max) {
530 hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
531 return 0;
532 }
533 /* check the rate is within the range */
534 if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
535 hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max);
536 return 0;
537 }
538 if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
539 hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min);
540 return 0;
541 }
542 /* check whether the period time is >= the data packet interval */
543 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) {
544 ptime = 125 * (1 << fp->datainterval);
545 if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
546 hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max);
547 return 0;
548 }
549 }
550 return 1;
551}
552
553static int hw_rule_rate(struct snd_pcm_hw_params *params,
554 struct snd_pcm_hw_rule *rule)
555{
556 struct snd_usb_substream *subs = rule->private;
557 struct list_head *p;
558 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
559 unsigned int rmin, rmax;
560 int changed;
561
562 hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
563 changed = 0;
564 rmin = rmax = 0;
565 list_for_each(p, &subs->fmt_list) {
566 struct audioformat *fp;
567 fp = list_entry(p, struct audioformat, list);
568 if (!hw_check_valid_format(subs, params, fp))
569 continue;
570 if (changed++) {
571 if (rmin > fp->rate_min)
572 rmin = fp->rate_min;
573 if (rmax < fp->rate_max)
574 rmax = fp->rate_max;
575 } else {
576 rmin = fp->rate_min;
577 rmax = fp->rate_max;
578 }
579 }
580
581 if (!changed) {
582 hwc_debug(" --> get empty\n");
583 it->empty = 1;
584 return -EINVAL;
585 }
586
587 changed = 0;
588 if (it->min < rmin) {
589 it->min = rmin;
590 it->openmin = 0;
591 changed = 1;
592 }
593 if (it->max > rmax) {
594 it->max = rmax;
595 it->openmax = 0;
596 changed = 1;
597 }
598 if (snd_interval_checkempty(it)) {
599 it->empty = 1;
600 return -EINVAL;
601 }
602 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
603 return changed;
604}
605
606
607static int hw_rule_channels(struct snd_pcm_hw_params *params,
608 struct snd_pcm_hw_rule *rule)
609{
610 struct snd_usb_substream *subs = rule->private;
611 struct list_head *p;
612 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
613 unsigned int rmin, rmax;
614 int changed;
615
616 hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
617 changed = 0;
618 rmin = rmax = 0;
619 list_for_each(p, &subs->fmt_list) {
620 struct audioformat *fp;
621 fp = list_entry(p, struct audioformat, list);
622 if (!hw_check_valid_format(subs, params, fp))
623 continue;
624 if (changed++) {
625 if (rmin > fp->channels)
626 rmin = fp->channels;
627 if (rmax < fp->channels)
628 rmax = fp->channels;
629 } else {
630 rmin = fp->channels;
631 rmax = fp->channels;
632 }
633 }
634
635 if (!changed) {
636 hwc_debug(" --> get empty\n");
637 it->empty = 1;
638 return -EINVAL;
639 }
640
641 changed = 0;
642 if (it->min < rmin) {
643 it->min = rmin;
644 it->openmin = 0;
645 changed = 1;
646 }
647 if (it->max > rmax) {
648 it->max = rmax;
649 it->openmax = 0;
650 changed = 1;
651 }
652 if (snd_interval_checkempty(it)) {
653 it->empty = 1;
654 return -EINVAL;
655 }
656 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
657 return changed;
658}
659
660static int hw_rule_format(struct snd_pcm_hw_params *params,
661 struct snd_pcm_hw_rule *rule)
662{
663 struct snd_usb_substream *subs = rule->private;
664 struct list_head *p;
665 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
666 u64 fbits;
667 u32 oldbits[2];
668 int changed;
669
670 hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
671 fbits = 0;
672 list_for_each(p, &subs->fmt_list) {
673 struct audioformat *fp;
674 fp = list_entry(p, struct audioformat, list);
675 if (!hw_check_valid_format(subs, params, fp))
676 continue;
677 fbits |= fp->formats;
678 }
679
680 oldbits[0] = fmt->bits[0];
681 oldbits[1] = fmt->bits[1];
682 fmt->bits[0] &= (u32)fbits;
683 fmt->bits[1] &= (u32)(fbits >> 32);
684 if (!fmt->bits[0] && !fmt->bits[1]) {
685 hwc_debug(" --> get empty\n");
686 return -EINVAL;
687 }
688 changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
689 hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
690 return changed;
691}
692
693static int hw_rule_period_time(struct snd_pcm_hw_params *params,
694 struct snd_pcm_hw_rule *rule)
695{
696 struct snd_usb_substream *subs = rule->private;
697 struct audioformat *fp;
698 struct snd_interval *it;
699 unsigned char min_datainterval;
700 unsigned int pmin;
701 int changed;
702
703 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
704 hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max);
705 min_datainterval = 0xff;
706 list_for_each_entry(fp, &subs->fmt_list, list) {
707 if (!hw_check_valid_format(subs, params, fp))
708 continue;
709 min_datainterval = min(min_datainterval, fp->datainterval);
710 }
711 if (min_datainterval == 0xff) {
712 hwc_debug(" --> get emtpy\n");
713 it->empty = 1;
714 return -EINVAL;
715 }
716 pmin = 125 * (1 << min_datainterval);
717 changed = 0;
718 if (it->min < pmin) {
719 it->min = pmin;
720 it->openmin = 0;
721 changed = 1;
722 }
723 if (snd_interval_checkempty(it)) {
724 it->empty = 1;
725 return -EINVAL;
726 }
727 hwc_debug(" --> (%u,%u) (changed = %d)\n", it->min, it->max, changed);
728 return changed;
729}
730
731/*
732 * If the device supports unusual bit rates, does the request meet these?
733 */
734static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
735 struct snd_usb_substream *subs)
736{
737 struct audioformat *fp;
738 int count = 0, needs_knot = 0;
739 int err;
740
741 list_for_each_entry(fp, &subs->fmt_list, list) {
742 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
743 return 0;
744 count += fp->nr_rates;
745 if (fp->rates & SNDRV_PCM_RATE_KNOT)
746 needs_knot = 1;
747 }
748 if (!needs_knot)
749 return 0;
750
751 subs->rate_list.count = count;
752 subs->rate_list.list = kmalloc(sizeof(int) * count, GFP_KERNEL);
753 subs->rate_list.mask = 0;
754 count = 0;
755 list_for_each_entry(fp, &subs->fmt_list, list) {
756 int i;
757 for (i = 0; i < fp->nr_rates; i++)
758 subs->rate_list.list[count++] = fp->rate_table[i];
759 }
760 err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
761 &subs->rate_list);
762 if (err < 0)
763 return err;
764
765 return 0;
766}
767
768
769/*
770 * set up the runtime hardware information.
771 */
772
773static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
774{
775 struct list_head *p;
776 unsigned int pt, ptmin;
777 int param_period_time_if_needed;
778 int err;
779
780 runtime->hw.formats = subs->formats;
781
782 runtime->hw.rate_min = 0x7fffffff;
783 runtime->hw.rate_max = 0;
784 runtime->hw.channels_min = 256;
785 runtime->hw.channels_max = 0;
786 runtime->hw.rates = 0;
787 ptmin = UINT_MAX;
788 /* check min/max rates and channels */
789 list_for_each(p, &subs->fmt_list) {
790 struct audioformat *fp;
791 fp = list_entry(p, struct audioformat, list);
792 runtime->hw.rates |= fp->rates;
793 if (runtime->hw.rate_min > fp->rate_min)
794 runtime->hw.rate_min = fp->rate_min;
795 if (runtime->hw.rate_max < fp->rate_max)
796 runtime->hw.rate_max = fp->rate_max;
797 if (runtime->hw.channels_min > fp->channels)
798 runtime->hw.channels_min = fp->channels;
799 if (runtime->hw.channels_max < fp->channels)
800 runtime->hw.channels_max = fp->channels;
801 if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
802 /* FIXME: there might be more than one audio formats... */
803 runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
804 fp->frame_size;
805 }
806 pt = 125 * (1 << fp->datainterval);
807 ptmin = min(ptmin, pt);
808 }
809
810 param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
811 if (snd_usb_get_speed(subs->dev) != USB_SPEED_HIGH)
812 /* full speed devices have fixed data packet interval */
813 ptmin = 1000;
814 if (ptmin == 1000)
815 /* if period time doesn't go below 1 ms, no rules needed */
816 param_period_time_if_needed = -1;
817 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
818 ptmin, UINT_MAX);
819
820 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
821 hw_rule_rate, subs,
822 SNDRV_PCM_HW_PARAM_FORMAT,
823 SNDRV_PCM_HW_PARAM_CHANNELS,
824 param_period_time_if_needed,
825 -1)) < 0)
826 return err;
827 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
828 hw_rule_channels, subs,
829 SNDRV_PCM_HW_PARAM_FORMAT,
830 SNDRV_PCM_HW_PARAM_RATE,
831 param_period_time_if_needed,
832 -1)) < 0)
833 return err;
834 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
835 hw_rule_format, subs,
836 SNDRV_PCM_HW_PARAM_RATE,
837 SNDRV_PCM_HW_PARAM_CHANNELS,
838 param_period_time_if_needed,
839 -1)) < 0)
840 return err;
841 if (param_period_time_if_needed >= 0) {
842 err = snd_pcm_hw_rule_add(runtime, 0,
843 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
844 hw_rule_period_time, subs,
845 SNDRV_PCM_HW_PARAM_FORMAT,
846 SNDRV_PCM_HW_PARAM_CHANNELS,
847 SNDRV_PCM_HW_PARAM_RATE,
848 -1);
849 if (err < 0)
850 return err;
851 }
852 if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
853 return err;
854 return 0;
855}
856
857static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction)
858{
859 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
860 struct snd_pcm_runtime *runtime = substream->runtime;
861 struct snd_usb_substream *subs = &as->substream[direction];
862
863 subs->interface = -1;
864 subs->altset_idx = 0;
865 runtime->hw = snd_usb_hardware;
866 runtime->private_data = subs;
867 subs->pcm_substream = substream;
868 return setup_hw_info(runtime, subs);
869}
870
871static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
872{
873 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
874 struct snd_usb_substream *subs = &as->substream[direction];
875
876 if (!as->chip->shutdown && subs->interface >= 0) {
877 usb_set_interface(subs->dev, subs->interface, 0);
878 subs->interface = -1;
879 }
880 subs->pcm_substream = NULL;
881 return 0;
882}
883
884static int snd_usb_playback_open(struct snd_pcm_substream *substream)
885{
886 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK);
887}
888
889static int snd_usb_playback_close(struct snd_pcm_substream *substream)
890{
891 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
892}
893
894static int snd_usb_capture_open(struct snd_pcm_substream *substream)
895{
896 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE);
897}
898
899static int snd_usb_capture_close(struct snd_pcm_substream *substream)
900{
901 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
902}
903
904static struct snd_pcm_ops snd_usb_playback_ops = {
905 .open = snd_usb_playback_open,
906 .close = snd_usb_playback_close,
907 .ioctl = snd_pcm_lib_ioctl,
908 .hw_params = snd_usb_hw_params,
909 .hw_free = snd_usb_hw_free,
910 .prepare = snd_usb_pcm_prepare,
911 .trigger = snd_usb_substream_playback_trigger,
912 .pointer = snd_usb_pcm_pointer,
913 .page = snd_pcm_lib_get_vmalloc_page,
914 .mmap = snd_pcm_lib_mmap_vmalloc,
915};
916
917static struct snd_pcm_ops snd_usb_capture_ops = {
918 .open = snd_usb_capture_open,
919 .close = snd_usb_capture_close,
920 .ioctl = snd_pcm_lib_ioctl,
921 .hw_params = snd_usb_hw_params,
922 .hw_free = snd_usb_hw_free,
923 .prepare = snd_usb_pcm_prepare,
924 .trigger = snd_usb_substream_capture_trigger,
925 .pointer = snd_usb_pcm_pointer,
926 .page = snd_pcm_lib_get_vmalloc_page,
927 .mmap = snd_pcm_lib_mmap_vmalloc,
928};
929
930void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream)
931{
932 snd_pcm_set_ops(pcm, stream,
933 stream == SNDRV_PCM_STREAM_PLAYBACK ?
934 &snd_usb_playback_ops : &snd_usb_capture_ops);
935}
diff --git a/sound/usb/pcm.h b/sound/usb/pcm.h
new file mode 100644
index 000000000000..1c931b68f3b5
--- /dev/null
+++ b/sound/usb/pcm.h
@@ -0,0 +1,14 @@
1#ifndef __USBAUDIO_PCM_H
2#define __USBAUDIO_PCM_H
3
4void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream);
5
6int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
7 struct usb_host_interface *alts,
8 struct audioformat *fmt);
9
10int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
11 struct usb_host_interface *alts,
12 struct audioformat *fmt, int rate);
13
14#endif /* __USBAUDIO_PCM_H */
diff --git a/sound/usb/proc.c b/sound/usb/proc.c
new file mode 100644
index 000000000000..f5e3f356b95f
--- /dev/null
+++ b/sound/usb/proc.c
@@ -0,0 +1,168 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 */
17
18#include <linux/init.h>
19#include <linux/usb.h>
20
21#include <sound/core.h>
22#include <sound/info.h>
23#include <sound/pcm.h>
24
25#include "usbaudio.h"
26#include "helper.h"
27#include "card.h"
28#include "proc.h"
29
30/* convert our full speed USB rate into sampling rate in Hz */
31static inline unsigned get_full_speed_hz(unsigned int usb_rate)
32{
33 return (usb_rate * 125 + (1 << 12)) >> 13;
34}
35
36/* convert our high speed USB rate into sampling rate in Hz */
37static inline unsigned get_high_speed_hz(unsigned int usb_rate)
38{
39 return (usb_rate * 125 + (1 << 9)) >> 10;
40}
41
42/*
43 * common proc files to show the usb device info
44 */
45static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
46{
47 struct snd_usb_audio *chip = entry->private_data;
48 if (!chip->shutdown)
49 snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
50}
51
52static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
53{
54 struct snd_usb_audio *chip = entry->private_data;
55 if (!chip->shutdown)
56 snd_iprintf(buffer, "%04x:%04x\n",
57 USB_ID_VENDOR(chip->usb_id),
58 USB_ID_PRODUCT(chip->usb_id));
59}
60
61void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
62{
63 struct snd_info_entry *entry;
64 if (!snd_card_proc_new(chip->card, "usbbus", &entry))
65 snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
66 if (!snd_card_proc_new(chip->card, "usbid", &entry))
67 snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
68}
69
70/*
71 * proc interface for list the supported pcm formats
72 */
73static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
74{
75 struct list_head *p;
76 static char *sync_types[4] = {
77 "NONE", "ASYNC", "ADAPTIVE", "SYNC"
78 };
79
80 list_for_each(p, &subs->fmt_list) {
81 struct audioformat *fp;
82 snd_pcm_format_t fmt;
83 fp = list_entry(p, struct audioformat, list);
84 snd_iprintf(buffer, " Interface %d\n", fp->iface);
85 snd_iprintf(buffer, " Altset %d\n", fp->altsetting);
86 snd_iprintf(buffer, " Format:");
87 for (fmt = 0; fmt <= SNDRV_PCM_FORMAT_LAST; ++fmt)
88 if (fp->formats & (1uLL << fmt))
89 snd_iprintf(buffer, " %s",
90 snd_pcm_format_name(fmt));
91 snd_iprintf(buffer, "\n");
92 snd_iprintf(buffer, " Channels: %d\n", fp->channels);
93 snd_iprintf(buffer, " Endpoint: %d %s (%s)\n",
94 fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
95 fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
96 sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]);
97 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
98 snd_iprintf(buffer, " Rates: %d - %d (continuous)\n",
99 fp->rate_min, fp->rate_max);
100 } else {
101 unsigned int i;
102 snd_iprintf(buffer, " Rates: ");
103 for (i = 0; i < fp->nr_rates; i++) {
104 if (i > 0)
105 snd_iprintf(buffer, ", ");
106 snd_iprintf(buffer, "%d", fp->rate_table[i]);
107 }
108 snd_iprintf(buffer, "\n");
109 }
110 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
111 snd_iprintf(buffer, " Data packet interval: %d us\n",
112 125 * (1 << fp->datainterval));
113 // snd_iprintf(buffer, " Max Packet Size = %d\n", fp->maxpacksize);
114 // snd_iprintf(buffer, " EP Attribute = %#x\n", fp->attributes);
115 }
116}
117
118static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
119{
120 if (subs->running) {
121 unsigned int i;
122 snd_iprintf(buffer, " Status: Running\n");
123 snd_iprintf(buffer, " Interface = %d\n", subs->interface);
124 snd_iprintf(buffer, " Altset = %d\n", subs->altset_idx);
125 snd_iprintf(buffer, " URBs = %d [ ", subs->nurbs);
126 for (i = 0; i < subs->nurbs; i++)
127 snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
128 snd_iprintf(buffer, "]\n");
129 snd_iprintf(buffer, " Packet Size = %d\n", subs->curpacksize);
130 snd_iprintf(buffer, " Momentary freq = %u Hz (%#x.%04x)\n",
131 snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
132 ? get_full_speed_hz(subs->freqm)
133 : get_high_speed_hz(subs->freqm),
134 subs->freqm >> 16, subs->freqm & 0xffff);
135 } else {
136 snd_iprintf(buffer, " Status: Stop\n");
137 }
138}
139
140static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
141{
142 struct snd_usb_stream *stream = entry->private_data;
143
144 snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
145
146 if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
147 snd_iprintf(buffer, "\nPlayback:\n");
148 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
149 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
150 }
151 if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
152 snd_iprintf(buffer, "\nCapture:\n");
153 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
154 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
155 }
156}
157
158void snd_usb_proc_pcm_format_add(struct snd_usb_stream *stream)
159{
160 struct snd_info_entry *entry;
161 char name[32];
162 struct snd_card *card = stream->chip->card;
163
164 sprintf(name, "stream%d", stream->pcm_index);
165 if (!snd_card_proc_new(card, name, &entry))
166 snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
167}
168
diff --git a/sound/usb/proc.h b/sound/usb/proc.h
new file mode 100644
index 000000000000..a45b765e4cf1
--- /dev/null
+++ b/sound/usb/proc.h
@@ -0,0 +1,8 @@
1#ifndef __USBAUDIO_PROC_H
2#define __USBAUDIO_PROC_H
3
4void snd_usb_audio_create_proc(struct snd_usb_audio *chip);
5void snd_usb_proc_pcm_format_add(struct snd_usb_stream *stream);
6
7#endif /* __USBAUDIO_PROC_H */
8
diff --git a/sound/usb/usbquirks.h b/sound/usb/quirks-table.h
index 2b426c1fd0e8..91ddef31bcbd 100644
--- a/sound/usb/usbquirks.h
+++ b/sound/usb/quirks-table.h
@@ -279,7 +279,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
279 .ifnum = 0, 279 .ifnum = 0,
280 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 280 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
281 .data = & (const struct audioformat) { 281 .data = & (const struct audioformat) {
282 .format = SNDRV_PCM_FORMAT_S16_LE, 282 .formats = SNDRV_PCM_FMTBIT_S16_LE,
283 .channels = 4, 283 .channels = 4,
284 .iface = 0, 284 .iface = 0,
285 .altsetting = 1, 285 .altsetting = 1,
@@ -296,7 +296,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
296 .ifnum = 1, 296 .ifnum = 1,
297 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 297 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
298 .data = & (const struct audioformat) { 298 .data = & (const struct audioformat) {
299 .format = SNDRV_PCM_FORMAT_S16_LE, 299 .formats = SNDRV_PCM_FMTBIT_S16_LE,
300 .channels = 2, 300 .channels = 2,
301 .iface = 1, 301 .iface = 1,
302 .altsetting = 1, 302 .altsetting = 1,
@@ -580,7 +580,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
580 .ifnum = 0, 580 .ifnum = 0,
581 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 581 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
582 .data = & (const struct audioformat) { 582 .data = & (const struct audioformat) {
583 .format = SNDRV_PCM_FORMAT_S24_3LE, 583 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
584 .channels = 2, 584 .channels = 2,
585 .iface = 0, 585 .iface = 0,
586 .altsetting = 1, 586 .altsetting = 1,
@@ -597,7 +597,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
597 .ifnum = 1, 597 .ifnum = 1,
598 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 598 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
599 .data = & (const struct audioformat) { 599 .data = & (const struct audioformat) {
600 .format = SNDRV_PCM_FORMAT_S24_3LE, 600 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
601 .channels = 2, 601 .channels = 2,
602 .iface = 1, 602 .iface = 1,
603 .altsetting = 1, 603 .altsetting = 1,
@@ -793,7 +793,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
793 .ifnum = 1, 793 .ifnum = 1,
794 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 794 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
795 .data = & (const struct audioformat) { 795 .data = & (const struct audioformat) {
796 .format = SNDRV_PCM_FORMAT_S24_3LE, 796 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
797 .channels = 2, 797 .channels = 2,
798 .iface = 1, 798 .iface = 1,
799 .altsetting = 1, 799 .altsetting = 1,
@@ -810,7 +810,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
810 .ifnum = 2, 810 .ifnum = 2,
811 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 811 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
812 .data = & (const struct audioformat) { 812 .data = & (const struct audioformat) {
813 .format = SNDRV_PCM_FORMAT_S24_3LE, 813 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
814 .channels = 2, 814 .channels = 2,
815 .iface = 2, 815 .iface = 2,
816 .altsetting = 1, 816 .altsetting = 1,
@@ -1826,6 +1826,60 @@ YAMAHA_DEVICE(0x7010, "UB99"),
1826 } 1826 }
1827 } 1827 }
1828}, 1828},
1829{
1830 USB_DEVICE(0x0763, 0x2080),
1831 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1832 /* .vendor_name = "M-Audio", */
1833 /* .product_name = "Fast Track Ultra 8", */
1834 .ifnum = QUIRK_ANY_INTERFACE,
1835 .type = QUIRK_COMPOSITE,
1836 .data = & (const struct snd_usb_audio_quirk[]) {
1837 {
1838 .ifnum = 0,
1839 .type = QUIRK_IGNORE_INTERFACE
1840 },
1841 {
1842 .ifnum = 1,
1843 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1844 },
1845 {
1846 .ifnum = 2,
1847 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1848 },
1849 /* interface 3 (MIDI) is standard compliant */
1850 {
1851 .ifnum = -1
1852 }
1853 }
1854 }
1855},
1856{
1857 USB_DEVICE(0x0763, 0x2081),
1858 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1859 /* .vendor_name = "M-Audio", */
1860 /* .product_name = "Fast Track Ultra 8R", */
1861 .ifnum = QUIRK_ANY_INTERFACE,
1862 .type = QUIRK_COMPOSITE,
1863 .data = & (const struct snd_usb_audio_quirk[]) {
1864 {
1865 .ifnum = 0,
1866 .type = QUIRK_IGNORE_INTERFACE
1867 },
1868 {
1869 .ifnum = 1,
1870 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1871 },
1872 {
1873 .ifnum = 2,
1874 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1875 },
1876 /* interface 3 (MIDI) is standard compliant */
1877 {
1878 .ifnum = -1
1879 }
1880 }
1881 }
1882},
1829 1883
1830/* Casio devices */ 1884/* Casio devices */
1831{ 1885{
@@ -2203,7 +2257,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
2203 .ifnum = 1, 2257 .ifnum = 1,
2204 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2258 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2205 .data = &(const struct audioformat) { 2259 .data = &(const struct audioformat) {
2206 .format = SNDRV_PCM_FORMAT_S24_3BE, 2260 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2207 .channels = 2, 2261 .channels = 2,
2208 .iface = 1, 2262 .iface = 1,
2209 .altsetting = 1, 2263 .altsetting = 1,
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
new file mode 100644
index 000000000000..136e5b4cf6de
--- /dev/null
+++ b/sound/usb/quirks.c
@@ -0,0 +1,594 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17#include <linux/init.h>
18#include <linux/slab.h>
19#include <linux/usb.h>
20#include <linux/usb/audio.h>
21
22#include <sound/core.h>
23#include <sound/info.h>
24#include <sound/pcm.h>
25
26#include "usbaudio.h"
27#include "card.h"
28#include "mixer.h"
29#include "mixer_quirks.h"
30#include "midi.h"
31#include "quirks.h"
32#include "helper.h"
33#include "endpoint.h"
34#include "pcm.h"
35
36/*
37 * handle the quirks for the contained interfaces
38 */
39static int create_composite_quirk(struct snd_usb_audio *chip,
40 struct usb_interface *iface,
41 struct usb_driver *driver,
42 const struct snd_usb_audio_quirk *quirk)
43{
44 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
45 int err;
46
47 for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) {
48 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
49 if (!iface)
50 continue;
51 if (quirk->ifnum != probed_ifnum &&
52 usb_interface_claimed(iface))
53 continue;
54 err = snd_usb_create_quirk(chip, iface, driver, quirk);
55 if (err < 0)
56 return err;
57 if (quirk->ifnum != probed_ifnum)
58 usb_driver_claim_interface(driver, iface, (void *)-1L);
59 }
60 return 0;
61}
62
63static int ignore_interface_quirk(struct snd_usb_audio *chip,
64 struct usb_interface *iface,
65 struct usb_driver *driver,
66 const struct snd_usb_audio_quirk *quirk)
67{
68 return 0;
69}
70
71
72/*
73 * Allow alignment on audio sub-slot (channel samples) rather than
74 * on audio slots (audio frames)
75 */
76static int create_align_transfer_quirk(struct snd_usb_audio *chip,
77 struct usb_interface *iface,
78 struct usb_driver *driver,
79 const struct snd_usb_audio_quirk *quirk)
80{
81 chip->txfr_quirk = 1;
82 return 1; /* Continue with creating streams and mixer */
83}
84
85static int create_any_midi_quirk(struct snd_usb_audio *chip,
86 struct usb_interface *intf,
87 struct usb_driver *driver,
88 const struct snd_usb_audio_quirk *quirk)
89{
90 return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
91}
92
93/*
94 * create a stream for an interface with proper descriptors
95 */
96static int create_standard_audio_quirk(struct snd_usb_audio *chip,
97 struct usb_interface *iface,
98 struct usb_driver *driver,
99 const struct snd_usb_audio_quirk *quirk)
100{
101 struct usb_host_interface *alts;
102 struct usb_interface_descriptor *altsd;
103 int err;
104
105 alts = &iface->altsetting[0];
106 altsd = get_iface_desc(alts);
107 err = snd_usb_parse_audio_endpoints(chip, altsd->bInterfaceNumber);
108 if (err < 0) {
109 snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
110 altsd->bInterfaceNumber, err);
111 return err;
112 }
113 /* reset the current interface */
114 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
115 return 0;
116}
117
118/*
119 * create a stream for an endpoint/altsetting without proper descriptors
120 */
121static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
122 struct usb_interface *iface,
123 struct usb_driver *driver,
124 const struct snd_usb_audio_quirk *quirk)
125{
126 struct audioformat *fp;
127 struct usb_host_interface *alts;
128 int stream, err;
129 unsigned *rate_table = NULL;
130
131 fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
132 if (! fp) {
133 snd_printk(KERN_ERR "cannot memdup\n");
134 return -ENOMEM;
135 }
136 if (fp->nr_rates > 0) {
137 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
138 if (!rate_table) {
139 kfree(fp);
140 return -ENOMEM;
141 }
142 memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates);
143 fp->rate_table = rate_table;
144 }
145
146 stream = (fp->endpoint & USB_DIR_IN)
147 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
148 err = snd_usb_add_audio_endpoint(chip, stream, fp);
149 if (err < 0) {
150 kfree(fp);
151 kfree(rate_table);
152 return err;
153 }
154 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
155 fp->altset_idx >= iface->num_altsetting) {
156 kfree(fp);
157 kfree(rate_table);
158 return -EINVAL;
159 }
160 alts = &iface->altsetting[fp->altset_idx];
161 fp->datainterval = snd_usb_parse_datainterval(chip, alts);
162 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
163 usb_set_interface(chip->dev, fp->iface, 0);
164 snd_usb_init_pitch(chip, fp->iface, alts, fp);
165 snd_usb_init_sample_rate(chip, fp->iface, alts, fp, fp->rate_max);
166 return 0;
167}
168
169/*
170 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
171 * The only way to detect the sample rate is by looking at wMaxPacketSize.
172 */
173static int create_uaxx_quirk(struct snd_usb_audio *chip,
174 struct usb_interface *iface,
175 struct usb_driver *driver,
176 const struct snd_usb_audio_quirk *quirk)
177{
178 static const struct audioformat ua_format = {
179 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
180 .channels = 2,
181 .fmt_type = UAC_FORMAT_TYPE_I,
182 .altsetting = 1,
183 .altset_idx = 1,
184 .rates = SNDRV_PCM_RATE_CONTINUOUS,
185 };
186 struct usb_host_interface *alts;
187 struct usb_interface_descriptor *altsd;
188 struct audioformat *fp;
189 int stream, err;
190
191 /* both PCM and MIDI interfaces have 2 or more altsettings */
192 if (iface->num_altsetting < 2)
193 return -ENXIO;
194 alts = &iface->altsetting[1];
195 altsd = get_iface_desc(alts);
196
197 if (altsd->bNumEndpoints == 2) {
198 static const struct snd_usb_midi_endpoint_info ua700_ep = {
199 .out_cables = 0x0003,
200 .in_cables = 0x0003
201 };
202 static const struct snd_usb_audio_quirk ua700_quirk = {
203 .type = QUIRK_MIDI_FIXED_ENDPOINT,
204 .data = &ua700_ep
205 };
206 static const struct snd_usb_midi_endpoint_info uaxx_ep = {
207 .out_cables = 0x0001,
208 .in_cables = 0x0001
209 };
210 static const struct snd_usb_audio_quirk uaxx_quirk = {
211 .type = QUIRK_MIDI_FIXED_ENDPOINT,
212 .data = &uaxx_ep
213 };
214 const struct snd_usb_audio_quirk *quirk =
215 chip->usb_id == USB_ID(0x0582, 0x002b)
216 ? &ua700_quirk : &uaxx_quirk;
217 return snd_usbmidi_create(chip->card, iface,
218 &chip->midi_list, quirk);
219 }
220
221 if (altsd->bNumEndpoints != 1)
222 return -ENXIO;
223
224 fp = kmalloc(sizeof(*fp), GFP_KERNEL);
225 if (!fp)
226 return -ENOMEM;
227 memcpy(fp, &ua_format, sizeof(*fp));
228
229 fp->iface = altsd->bInterfaceNumber;
230 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
231 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
232 fp->datainterval = 0;
233 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
234
235 switch (fp->maxpacksize) {
236 case 0x120:
237 fp->rate_max = fp->rate_min = 44100;
238 break;
239 case 0x138:
240 case 0x140:
241 fp->rate_max = fp->rate_min = 48000;
242 break;
243 case 0x258:
244 case 0x260:
245 fp->rate_max = fp->rate_min = 96000;
246 break;
247 default:
248 snd_printk(KERN_ERR "unknown sample rate\n");
249 kfree(fp);
250 return -ENXIO;
251 }
252
253 stream = (fp->endpoint & USB_DIR_IN)
254 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
255 err = snd_usb_add_audio_endpoint(chip, stream, fp);
256 if (err < 0) {
257 kfree(fp);
258 return err;
259 }
260 usb_set_interface(chip->dev, fp->iface, 0);
261 return 0;
262}
263
264/*
265 * audio-interface quirks
266 *
267 * returns zero if no standard audio/MIDI parsing is needed.
268 * returns a postive value if standard audio/midi interfaces are parsed
269 * after this.
270 * returns a negative value at error.
271 */
272int snd_usb_create_quirk(struct snd_usb_audio *chip,
273 struct usb_interface *iface,
274 struct usb_driver *driver,
275 const struct snd_usb_audio_quirk *quirk)
276{
277 typedef int (*quirk_func_t)(struct snd_usb_audio *,
278 struct usb_interface *,
279 struct usb_driver *,
280 const struct snd_usb_audio_quirk *);
281 static const quirk_func_t quirk_funcs[] = {
282 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
283 [QUIRK_COMPOSITE] = create_composite_quirk,
284 [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
285 [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
286 [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
287 [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
288 [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
289 [QUIRK_MIDI_FASTLANE] = create_any_midi_quirk,
290 [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
291 [QUIRK_MIDI_CME] = create_any_midi_quirk,
292 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
293 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
294 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
295 [QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk
296 };
297
298 if (quirk->type < QUIRK_TYPE_COUNT) {
299 return quirk_funcs[quirk->type](chip, iface, driver, quirk);
300 } else {
301 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
302 return -ENXIO;
303 }
304}
305
306/*
307 * boot quirks
308 */
309
310#define EXTIGY_FIRMWARE_SIZE_OLD 794
311#define EXTIGY_FIRMWARE_SIZE_NEW 483
312
313static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
314{
315 struct usb_host_config *config = dev->actconfig;
316 int err;
317
318 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
319 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
320 snd_printdd("sending Extigy boot sequence...\n");
321 /* Send message to force it to reconnect with full interface. */
322 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
323 0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000);
324 if (err < 0) snd_printdd("error sending boot message: %d\n", err);
325 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
326 &dev->descriptor, sizeof(dev->descriptor));
327 config = dev->actconfig;
328 if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
329 err = usb_reset_configuration(dev);
330 if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
331 snd_printdd("extigy_boot: new boot length = %d\n",
332 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
333 return -ENODEV; /* quit this anyway */
334 }
335 return 0;
336}
337
338static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
339{
340 u8 buf = 1;
341
342 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
343 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
344 0, 0, &buf, 1, 1000);
345 if (buf == 0) {
346 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
347 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
348 1, 2000, NULL, 0, 1000);
349 return -ENODEV;
350 }
351 return 0;
352}
353
354/*
355 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
356 * documented in the device's data sheet.
357 */
358static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
359{
360 u8 buf[4];
361 buf[0] = 0x20;
362 buf[1] = value & 0xff;
363 buf[2] = (value >> 8) & 0xff;
364 buf[3] = reg;
365 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
366 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
367 0, 0, &buf, 4, 1000);
368}
369
370static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
371{
372 /*
373 * Enable line-out driver mode, set headphone source to front
374 * channels, enable stereo mic.
375 */
376 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
377}
378
379/*
380 * C-Media CM6206 is based on CM106 with two additional
381 * registers that are not documented in the data sheet.
382 * Values here are chosen based on sniffing USB traffic
383 * under Windows.
384 */
385static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
386{
387 int err, reg;
388 int val[] = {0x200c, 0x3000, 0xf800, 0x143f, 0x0000, 0x3000};
389
390 for (reg = 0; reg < ARRAY_SIZE(val); reg++) {
391 err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);
392 if (err < 0)
393 return err;
394 }
395
396 return err;
397}
398
399/*
400 * This call will put the synth in "USB send" mode, i.e it will send MIDI
401 * messages through USB (this is disabled at startup). The synth will
402 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
403 * sign on its LCD. Values here are chosen based on sniffing USB traffic
404 * under Windows.
405 */
406static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
407{
408 int err, actual_length;
409
410 /* "midi send" enable */
411 static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
412
413 void *buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
414 if (!buf)
415 return -ENOMEM;
416 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
417 ARRAY_SIZE(seq), &actual_length, 1000);
418 kfree(buf);
419 if (err < 0)
420 return err;
421
422 return 0;
423}
424
425/*
426 * Setup quirks
427 */
428#define AUDIOPHILE_SET 0x01 /* if set, parse device_setup */
429#define AUDIOPHILE_SET_DTS 0x02 /* if set, enable DTS Digital Output */
430#define AUDIOPHILE_SET_96K 0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */
431#define AUDIOPHILE_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */
432#define AUDIOPHILE_SET_DI 0x10 /* if set, enable Digital Input */
433#define AUDIOPHILE_SET_MASK 0x1F /* bit mask for setup value */
434#define AUDIOPHILE_SET_24B_48K_DI 0x19 /* value for 24bits+48KHz+Digital Input */
435#define AUDIOPHILE_SET_24B_48K_NOTDI 0x09 /* value for 24bits+48KHz+No Digital Input */
436#define AUDIOPHILE_SET_16B_48K_DI 0x11 /* value for 16bits+48KHz+Digital Input */
437#define AUDIOPHILE_SET_16B_48K_NOTDI 0x01 /* value for 16bits+48KHz+No Digital Input */
438
439static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
440 int iface,
441 int altno)
442{
443 /* Reset ALL ifaces to 0 altsetting.
444 * Call it for every possible altsetting of every interface.
445 */
446 usb_set_interface(chip->dev, iface, 0);
447
448 if (chip->setup & AUDIOPHILE_SET) {
449 if ((chip->setup & AUDIOPHILE_SET_DTS)
450 && altno != 6)
451 return 1; /* skip this altsetting */
452 if ((chip->setup & AUDIOPHILE_SET_96K)
453 && altno != 1)
454 return 1; /* skip this altsetting */
455 if ((chip->setup & AUDIOPHILE_SET_MASK) ==
456 AUDIOPHILE_SET_24B_48K_DI && altno != 2)
457 return 1; /* skip this altsetting */
458 if ((chip->setup & AUDIOPHILE_SET_MASK) ==
459 AUDIOPHILE_SET_24B_48K_NOTDI && altno != 3)
460 return 1; /* skip this altsetting */
461 if ((chip->setup & AUDIOPHILE_SET_MASK) ==
462 AUDIOPHILE_SET_16B_48K_DI && altno != 4)
463 return 1; /* skip this altsetting */
464 if ((chip->setup & AUDIOPHILE_SET_MASK) ==
465 AUDIOPHILE_SET_16B_48K_NOTDI && altno != 5)
466 return 1; /* skip this altsetting */
467 }
468
469 return 0; /* keep this altsetting */
470}
471
472int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,
473 int iface,
474 int altno)
475{
476 /* audiophile usb: skip altsets incompatible with device_setup */
477 if (chip->usb_id == USB_ID(0x0763, 0x2003))
478 return audiophile_skip_setting_quirk(chip, iface, altno);
479
480 return 0;
481}
482
483int snd_usb_apply_boot_quirk(struct usb_device *dev,
484 struct usb_interface *intf,
485 const struct snd_usb_audio_quirk *quirk)
486{
487 u32 id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
488 le16_to_cpu(dev->descriptor.idProduct));
489
490 /* SB Extigy needs special boot-up sequence */
491 /* if more models come, this will go to the quirk list. */
492 if (id == USB_ID(0x041e, 0x3000))
493 return snd_usb_extigy_boot_quirk(dev, intf);
494
495 /* SB Audigy 2 NX needs its own boot-up magic, too */
496 if (id == USB_ID(0x041e, 0x3020))
497 return snd_usb_audigy2nx_boot_quirk(dev);
498
499 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
500 if (id == USB_ID(0x10f5, 0x0200))
501 return snd_usb_cm106_boot_quirk(dev);
502
503 /* C-Media CM6206 / CM106-Like Sound Device */
504 if (id == USB_ID(0x0d8c, 0x0102))
505 return snd_usb_cm6206_boot_quirk(dev);
506
507 /* Access Music VirusTI Desktop */
508 if (id == USB_ID(0x133e, 0x0815))
509 return snd_usb_accessmusic_boot_quirk(dev);
510
511 return 0;
512}
513
514/*
515 * check if the device uses big-endian samples
516 */
517int snd_usb_is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
518{
519 switch (chip->usb_id) {
520 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
521 if (fp->endpoint & USB_DIR_IN)
522 return 1;
523 break;
524 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
525 if (chip->setup == 0x00 ||
526 fp->altsetting==1 || fp->altsetting==2 || fp->altsetting==3)
527 return 1;
528 }
529 return 0;
530}
531
532/*
533 * For E-Mu 0404USB/0202USB/TrackerPre sample rate should be set for device,
534 * not for interface.
535 */
536
537enum {
538 EMU_QUIRK_SR_44100HZ = 0,
539 EMU_QUIRK_SR_48000HZ,
540 EMU_QUIRK_SR_88200HZ,
541 EMU_QUIRK_SR_96000HZ,
542 EMU_QUIRK_SR_176400HZ,
543 EMU_QUIRK_SR_192000HZ
544};
545
546static void set_format_emu_quirk(struct snd_usb_substream *subs,
547 struct audioformat *fmt)
548{
549 unsigned char emu_samplerate_id = 0;
550
551 /* When capture is active
552 * sample rate shouldn't be changed
553 * by playback substream
554 */
555 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
556 if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1)
557 return;
558 }
559
560 switch (fmt->rate_min) {
561 case 48000:
562 emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
563 break;
564 case 88200:
565 emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
566 break;
567 case 96000:
568 emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
569 break;
570 case 176400:
571 emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
572 break;
573 case 192000:
574 emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
575 break;
576 default:
577 emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
578 break;
579 }
580 snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
581}
582
583void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
584 struct audioformat *fmt)
585{
586 switch (subs->stream->chip->usb_id) {
587 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
588 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
589 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
590 set_format_emu_quirk(subs, fmt);
591 break;
592 }
593}
594
diff --git a/sound/usb/quirks.h b/sound/usb/quirks.h
new file mode 100644
index 000000000000..03e5e94098cd
--- /dev/null
+++ b/sound/usb/quirks.h
@@ -0,0 +1,23 @@
1#ifndef __USBAUDIO_QUIRKS_H
2#define __USBAUDIO_QUIRKS_H
3
4int snd_usb_create_quirk(struct snd_usb_audio *chip,
5 struct usb_interface *iface,
6 struct usb_driver *driver,
7 const struct snd_usb_audio_quirk *quirk);
8
9int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,
10 int iface,
11 int altno);
12
13int snd_usb_apply_boot_quirk(struct usb_device *dev,
14 struct usb_interface *intf,
15 const struct snd_usb_audio_quirk *quirk);
16
17void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
18 struct audioformat *fmt);
19
20int snd_usb_is_big_endian_format(struct snd_usb_audio *chip,
21 struct audioformat *fp);
22
23#endif /* __USBAUDIO_QUIRKS_H */
diff --git a/sound/usb/urb.c b/sound/usb/urb.c
new file mode 100644
index 000000000000..5570a2ba5736
--- /dev/null
+++ b/sound/usb/urb.c
@@ -0,0 +1,995 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 */
17
18#include <linux/gfp.h>
19#include <linux/init.h>
20#include <linux/usb.h>
21#include <linux/usb/audio.h>
22
23#include <sound/core.h>
24#include <sound/pcm.h>
25
26#include "usbaudio.h"
27#include "helper.h"
28#include "card.h"
29#include "urb.h"
30#include "pcm.h"
31
32/*
33 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
34 * this will overflow at approx 524 kHz
35 */
36static inline unsigned get_usb_full_speed_rate(unsigned int rate)
37{
38 return ((rate << 13) + 62) / 125;
39}
40
41/*
42 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
43 * this will overflow at approx 4 MHz
44 */
45static inline unsigned get_usb_high_speed_rate(unsigned int rate)
46{
47 return ((rate << 10) + 62) / 125;
48}
49
50/*
51 * unlink active urbs.
52 */
53static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep)
54{
55 struct snd_usb_audio *chip = subs->stream->chip;
56 unsigned int i;
57 int async;
58
59 subs->running = 0;
60
61 if (!force && subs->stream->chip->shutdown) /* to be sure... */
62 return -EBADFD;
63
64 async = !can_sleep && chip->async_unlink;
65
66 if (!async && in_interrupt())
67 return 0;
68
69 for (i = 0; i < subs->nurbs; i++) {
70 if (test_bit(i, &subs->active_mask)) {
71 if (!test_and_set_bit(i, &subs->unlink_mask)) {
72 struct urb *u = subs->dataurb[i].urb;
73 if (async)
74 usb_unlink_urb(u);
75 else
76 usb_kill_urb(u);
77 }
78 }
79 }
80 if (subs->syncpipe) {
81 for (i = 0; i < SYNC_URBS; i++) {
82 if (test_bit(i+16, &subs->active_mask)) {
83 if (!test_and_set_bit(i+16, &subs->unlink_mask)) {
84 struct urb *u = subs->syncurb[i].urb;
85 if (async)
86 usb_unlink_urb(u);
87 else
88 usb_kill_urb(u);
89 }
90 }
91 }
92 }
93 return 0;
94}
95
96
97/*
98 * release a urb data
99 */
100static void release_urb_ctx(struct snd_urb_ctx *u)
101{
102 if (u->urb) {
103 if (u->buffer_size)
104 usb_buffer_free(u->subs->dev, u->buffer_size,
105 u->urb->transfer_buffer,
106 u->urb->transfer_dma);
107 usb_free_urb(u->urb);
108 u->urb = NULL;
109 }
110}
111
112/*
113 * wait until all urbs are processed.
114 */
115static int wait_clear_urbs(struct snd_usb_substream *subs)
116{
117 unsigned long end_time = jiffies + msecs_to_jiffies(1000);
118 unsigned int i;
119 int alive;
120
121 do {
122 alive = 0;
123 for (i = 0; i < subs->nurbs; i++) {
124 if (test_bit(i, &subs->active_mask))
125 alive++;
126 }
127 if (subs->syncpipe) {
128 for (i = 0; i < SYNC_URBS; i++) {
129 if (test_bit(i + 16, &subs->active_mask))
130 alive++;
131 }
132 }
133 if (! alive)
134 break;
135 schedule_timeout_uninterruptible(1);
136 } while (time_before(jiffies, end_time));
137 if (alive)
138 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
139 return 0;
140}
141
142/*
143 * release a substream
144 */
145void snd_usb_release_substream_urbs(struct snd_usb_substream *subs, int force)
146{
147 int i;
148
149 /* stop urbs (to be sure) */
150 deactivate_urbs(subs, force, 1);
151 wait_clear_urbs(subs);
152
153 for (i = 0; i < MAX_URBS; i++)
154 release_urb_ctx(&subs->dataurb[i]);
155 for (i = 0; i < SYNC_URBS; i++)
156 release_urb_ctx(&subs->syncurb[i]);
157 usb_buffer_free(subs->dev, SYNC_URBS * 4,
158 subs->syncbuf, subs->sync_dma);
159 subs->syncbuf = NULL;
160 subs->nurbs = 0;
161}
162
163/*
164 * complete callback from data urb
165 */
166static void snd_complete_urb(struct urb *urb)
167{
168 struct snd_urb_ctx *ctx = urb->context;
169 struct snd_usb_substream *subs = ctx->subs;
170 struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
171 int err = 0;
172
173 if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
174 !subs->running || /* can be stopped during retire callback */
175 (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
176 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
177 clear_bit(ctx->index, &subs->active_mask);
178 if (err < 0) {
179 snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
180 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
181 }
182 }
183}
184
185
186/*
187 * complete callback from sync urb
188 */
189static void snd_complete_sync_urb(struct urb *urb)
190{
191 struct snd_urb_ctx *ctx = urb->context;
192 struct snd_usb_substream *subs = ctx->subs;
193 struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
194 int err = 0;
195
196 if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
197 !subs->running || /* can be stopped during retire callback */
198 (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
199 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
200 clear_bit(ctx->index + 16, &subs->active_mask);
201 if (err < 0) {
202 snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
203 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
204 }
205 }
206}
207
208
209/*
210 * initialize a substream for plaback/capture
211 */
212int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
213 unsigned int period_bytes,
214 unsigned int rate,
215 unsigned int frame_bits)
216{
217 unsigned int maxsize, i;
218 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
219 unsigned int urb_packs, total_packs, packs_per_ms;
220 struct snd_usb_audio *chip = subs->stream->chip;
221
222 /* calculate the frequency in 16.16 format */
223 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
224 subs->freqn = get_usb_full_speed_rate(rate);
225 else
226 subs->freqn = get_usb_high_speed_rate(rate);
227 subs->freqm = subs->freqn;
228 /* calculate max. frequency */
229 if (subs->maxpacksize) {
230 /* whatever fits into a max. size packet */
231 maxsize = subs->maxpacksize;
232 subs->freqmax = (maxsize / (frame_bits >> 3))
233 << (16 - subs->datainterval);
234 } else {
235 /* no max. packet size: just take 25% higher than nominal */
236 subs->freqmax = subs->freqn + (subs->freqn >> 2);
237 maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3))
238 >> (16 - subs->datainterval);
239 }
240 subs->phase = 0;
241
242 if (subs->fill_max)
243 subs->curpacksize = subs->maxpacksize;
244 else
245 subs->curpacksize = maxsize;
246
247 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
248 packs_per_ms = 8 >> subs->datainterval;
249 else
250 packs_per_ms = 1;
251
252 if (is_playback) {
253 urb_packs = max(chip->nrpacks, 1);
254 urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
255 } else
256 urb_packs = 1;
257 urb_packs *= packs_per_ms;
258 if (subs->syncpipe)
259 urb_packs = min(urb_packs, 1U << subs->syncinterval);
260
261 /* decide how many packets to be used */
262 if (is_playback) {
263 unsigned int minsize, maxpacks;
264 /* determine how small a packet can be */
265 minsize = (subs->freqn >> (16 - subs->datainterval))
266 * (frame_bits >> 3);
267 /* with sync from device, assume it can be 12% lower */
268 if (subs->syncpipe)
269 minsize -= minsize >> 3;
270 minsize = max(minsize, 1u);
271 total_packs = (period_bytes + minsize - 1) / minsize;
272 /* we need at least two URBs for queueing */
273 if (total_packs < 2) {
274 total_packs = 2;
275 } else {
276 /* and we don't want too long a queue either */
277 maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
278 total_packs = min(total_packs, maxpacks);
279 }
280 } else {
281 while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
282 urb_packs >>= 1;
283 total_packs = MAX_URBS * urb_packs;
284 }
285 subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
286 if (subs->nurbs > MAX_URBS) {
287 /* too much... */
288 subs->nurbs = MAX_URBS;
289 total_packs = MAX_URBS * urb_packs;
290 } else if (subs->nurbs < 2) {
291 /* too little - we need at least two packets
292 * to ensure contiguous playback/capture
293 */
294 subs->nurbs = 2;
295 }
296
297 /* allocate and initialize data urbs */
298 for (i = 0; i < subs->nurbs; i++) {
299 struct snd_urb_ctx *u = &subs->dataurb[i];
300 u->index = i;
301 u->subs = subs;
302 u->packets = (i + 1) * total_packs / subs->nurbs
303 - i * total_packs / subs->nurbs;
304 u->buffer_size = maxsize * u->packets;
305 if (subs->fmt_type == UAC_FORMAT_TYPE_II)
306 u->packets++; /* for transfer delimiter */
307 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
308 if (!u->urb)
309 goto out_of_memory;
310 u->urb->transfer_buffer =
311 usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL,
312 &u->urb->transfer_dma);
313 if (!u->urb->transfer_buffer)
314 goto out_of_memory;
315 u->urb->pipe = subs->datapipe;
316 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
317 u->urb->interval = 1 << subs->datainterval;
318 u->urb->context = u;
319 u->urb->complete = snd_complete_urb;
320 }
321
322 if (subs->syncpipe) {
323 /* allocate and initialize sync urbs */
324 subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4,
325 GFP_KERNEL, &subs->sync_dma);
326 if (!subs->syncbuf)
327 goto out_of_memory;
328 for (i = 0; i < SYNC_URBS; i++) {
329 struct snd_urb_ctx *u = &subs->syncurb[i];
330 u->index = i;
331 u->subs = subs;
332 u->packets = 1;
333 u->urb = usb_alloc_urb(1, GFP_KERNEL);
334 if (!u->urb)
335 goto out_of_memory;
336 u->urb->transfer_buffer = subs->syncbuf + i * 4;
337 u->urb->transfer_dma = subs->sync_dma + i * 4;
338 u->urb->transfer_buffer_length = 4;
339 u->urb->pipe = subs->syncpipe;
340 u->urb->transfer_flags = URB_ISO_ASAP |
341 URB_NO_TRANSFER_DMA_MAP;
342 u->urb->number_of_packets = 1;
343 u->urb->interval = 1 << subs->syncinterval;
344 u->urb->context = u;
345 u->urb->complete = snd_complete_sync_urb;
346 }
347 }
348 return 0;
349
350out_of_memory:
351 snd_usb_release_substream_urbs(subs, 0);
352 return -ENOMEM;
353}
354
355/*
356 * prepare urb for full speed capture sync pipe
357 *
358 * fill the length and offset of each urb descriptor.
359 * the fixed 10.14 frequency is passed through the pipe.
360 */
361static int prepare_capture_sync_urb(struct snd_usb_substream *subs,
362 struct snd_pcm_runtime *runtime,
363 struct urb *urb)
364{
365 unsigned char *cp = urb->transfer_buffer;
366 struct snd_urb_ctx *ctx = urb->context;
367
368 urb->dev = ctx->subs->dev; /* we need to set this at each time */
369 urb->iso_frame_desc[0].length = 3;
370 urb->iso_frame_desc[0].offset = 0;
371 cp[0] = subs->freqn >> 2;
372 cp[1] = subs->freqn >> 10;
373 cp[2] = subs->freqn >> 18;
374 return 0;
375}
376
377/*
378 * prepare urb for high speed capture sync pipe
379 *
380 * fill the length and offset of each urb descriptor.
381 * the fixed 12.13 frequency is passed as 16.16 through the pipe.
382 */
383static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs,
384 struct snd_pcm_runtime *runtime,
385 struct urb *urb)
386{
387 unsigned char *cp = urb->transfer_buffer;
388 struct snd_urb_ctx *ctx = urb->context;
389
390 urb->dev = ctx->subs->dev; /* we need to set this at each time */
391 urb->iso_frame_desc[0].length = 4;
392 urb->iso_frame_desc[0].offset = 0;
393 cp[0] = subs->freqn;
394 cp[1] = subs->freqn >> 8;
395 cp[2] = subs->freqn >> 16;
396 cp[3] = subs->freqn >> 24;
397 return 0;
398}
399
400/*
401 * process after capture sync complete
402 * - nothing to do
403 */
404static int retire_capture_sync_urb(struct snd_usb_substream *subs,
405 struct snd_pcm_runtime *runtime,
406 struct urb *urb)
407{
408 return 0;
409}
410
411/*
412 * prepare urb for capture data pipe
413 *
414 * fill the offset and length of each descriptor.
415 *
416 * we use a temporary buffer to write the captured data.
417 * since the length of written data is determined by host, we cannot
418 * write onto the pcm buffer directly... the data is thus copied
419 * later at complete callback to the global buffer.
420 */
421static int prepare_capture_urb(struct snd_usb_substream *subs,
422 struct snd_pcm_runtime *runtime,
423 struct urb *urb)
424{
425 int i, offs;
426 struct snd_urb_ctx *ctx = urb->context;
427
428 offs = 0;
429 urb->dev = ctx->subs->dev; /* we need to set this at each time */
430 for (i = 0; i < ctx->packets; i++) {
431 urb->iso_frame_desc[i].offset = offs;
432 urb->iso_frame_desc[i].length = subs->curpacksize;
433 offs += subs->curpacksize;
434 }
435 urb->transfer_buffer_length = offs;
436 urb->number_of_packets = ctx->packets;
437 return 0;
438}
439
440/*
441 * process after capture complete
442 *
443 * copy the data from each desctiptor to the pcm buffer, and
444 * update the current position.
445 */
446static int retire_capture_urb(struct snd_usb_substream *subs,
447 struct snd_pcm_runtime *runtime,
448 struct urb *urb)
449{
450 unsigned long flags;
451 unsigned char *cp;
452 int i;
453 unsigned int stride, frames, bytes, oldptr;
454 int period_elapsed = 0;
455
456 stride = runtime->frame_bits >> 3;
457
458 for (i = 0; i < urb->number_of_packets; i++) {
459 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
460 if (urb->iso_frame_desc[i].status) {
461 snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
462 // continue;
463 }
464 bytes = urb->iso_frame_desc[i].actual_length;
465 frames = bytes / stride;
466 if (!subs->txfr_quirk)
467 bytes = frames * stride;
468 if (bytes % (runtime->sample_bits >> 3) != 0) {
469#ifdef CONFIG_SND_DEBUG_VERBOSE
470 int oldbytes = bytes;
471#endif
472 bytes = frames * stride;
473 snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
474 oldbytes, bytes);
475 }
476 /* update the current pointer */
477 spin_lock_irqsave(&subs->lock, flags);
478 oldptr = subs->hwptr_done;
479 subs->hwptr_done += bytes;
480 if (subs->hwptr_done >= runtime->buffer_size * stride)
481 subs->hwptr_done -= runtime->buffer_size * stride;
482 frames = (bytes + (oldptr % stride)) / stride;
483 subs->transfer_done += frames;
484 if (subs->transfer_done >= runtime->period_size) {
485 subs->transfer_done -= runtime->period_size;
486 period_elapsed = 1;
487 }
488 spin_unlock_irqrestore(&subs->lock, flags);
489 /* copy a data chunk */
490 if (oldptr + bytes > runtime->buffer_size * stride) {
491 unsigned int bytes1 =
492 runtime->buffer_size * stride - oldptr;
493 memcpy(runtime->dma_area + oldptr, cp, bytes1);
494 memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
495 } else {
496 memcpy(runtime->dma_area + oldptr, cp, bytes);
497 }
498 }
499 if (period_elapsed)
500 snd_pcm_period_elapsed(subs->pcm_substream);
501 return 0;
502}
503
504/*
505 * Process after capture complete when paused. Nothing to do.
506 */
507static int retire_paused_capture_urb(struct snd_usb_substream *subs,
508 struct snd_pcm_runtime *runtime,
509 struct urb *urb)
510{
511 return 0;
512}
513
514
515/*
516 * prepare urb for full speed playback sync pipe
517 *
518 * set up the offset and length to receive the current frequency.
519 */
520
521static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
522 struct snd_pcm_runtime *runtime,
523 struct urb *urb)
524{
525 struct snd_urb_ctx *ctx = urb->context;
526
527 urb->dev = ctx->subs->dev; /* we need to set this at each time */
528 urb->iso_frame_desc[0].length = 3;
529 urb->iso_frame_desc[0].offset = 0;
530 return 0;
531}
532
533/*
534 * prepare urb for high speed playback sync pipe
535 *
536 * set up the offset and length to receive the current frequency.
537 */
538
539static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs,
540 struct snd_pcm_runtime *runtime,
541 struct urb *urb)
542{
543 struct snd_urb_ctx *ctx = urb->context;
544
545 urb->dev = ctx->subs->dev; /* we need to set this at each time */
546 urb->iso_frame_desc[0].length = 4;
547 urb->iso_frame_desc[0].offset = 0;
548 return 0;
549}
550
551/*
552 * process after full speed playback sync complete
553 *
554 * retrieve the current 10.14 frequency from pipe, and set it.
555 * the value is referred in prepare_playback_urb().
556 */
557static int retire_playback_sync_urb(struct snd_usb_substream *subs,
558 struct snd_pcm_runtime *runtime,
559 struct urb *urb)
560{
561 unsigned int f;
562 unsigned long flags;
563
564 if (urb->iso_frame_desc[0].status == 0 &&
565 urb->iso_frame_desc[0].actual_length == 3) {
566 f = combine_triple((u8*)urb->transfer_buffer) << 2;
567 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
568 spin_lock_irqsave(&subs->lock, flags);
569 subs->freqm = f;
570 spin_unlock_irqrestore(&subs->lock, flags);
571 }
572 }
573
574 return 0;
575}
576
577/*
578 * process after high speed playback sync complete
579 *
580 * retrieve the current 12.13 frequency from pipe, and set it.
581 * the value is referred in prepare_playback_urb().
582 */
583static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs,
584 struct snd_pcm_runtime *runtime,
585 struct urb *urb)
586{
587 unsigned int f;
588 unsigned long flags;
589
590 if (urb->iso_frame_desc[0].status == 0 &&
591 urb->iso_frame_desc[0].actual_length == 4) {
592 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
593 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
594 spin_lock_irqsave(&subs->lock, flags);
595 subs->freqm = f;
596 spin_unlock_irqrestore(&subs->lock, flags);
597 }
598 }
599
600 return 0;
601}
602
603/*
604 * process after E-Mu 0202/0404/Tracker Pre high speed playback sync complete
605 *
606 * These devices return the number of samples per packet instead of the number
607 * of samples per microframe.
608 */
609static int retire_playback_sync_urb_hs_emu(struct snd_usb_substream *subs,
610 struct snd_pcm_runtime *runtime,
611 struct urb *urb)
612{
613 unsigned int f;
614 unsigned long flags;
615
616 if (urb->iso_frame_desc[0].status == 0 &&
617 urb->iso_frame_desc[0].actual_length == 4) {
618 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
619 f >>= subs->datainterval;
620 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
621 spin_lock_irqsave(&subs->lock, flags);
622 subs->freqm = f;
623 spin_unlock_irqrestore(&subs->lock, flags);
624 }
625 }
626
627 return 0;
628}
629
630/* determine the number of frames in the next packet */
631static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs)
632{
633 if (subs->fill_max)
634 return subs->maxframesize;
635 else {
636 subs->phase = (subs->phase & 0xffff)
637 + (subs->freqm << subs->datainterval);
638 return min(subs->phase >> 16, subs->maxframesize);
639 }
640}
641
642/*
643 * Prepare urb for streaming before playback starts or when paused.
644 *
645 * We don't have any data, so we send silence.
646 */
647static int prepare_nodata_playback_urb(struct snd_usb_substream *subs,
648 struct snd_pcm_runtime *runtime,
649 struct urb *urb)
650{
651 unsigned int i, offs, counts;
652 struct snd_urb_ctx *ctx = urb->context;
653 int stride = runtime->frame_bits >> 3;
654
655 offs = 0;
656 urb->dev = ctx->subs->dev;
657 for (i = 0; i < ctx->packets; ++i) {
658 counts = snd_usb_audio_next_packet_size(subs);
659 urb->iso_frame_desc[i].offset = offs * stride;
660 urb->iso_frame_desc[i].length = counts * stride;
661 offs += counts;
662 }
663 urb->number_of_packets = ctx->packets;
664 urb->transfer_buffer_length = offs * stride;
665 memset(urb->transfer_buffer,
666 runtime->format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0,
667 offs * stride);
668 return 0;
669}
670
671/*
672 * prepare urb for playback data pipe
673 *
674 * Since a URB can handle only a single linear buffer, we must use double
675 * buffering when the data to be transferred overflows the buffer boundary.
676 * To avoid inconsistencies when updating hwptr_done, we use double buffering
677 * for all URBs.
678 */
679static int prepare_playback_urb(struct snd_usb_substream *subs,
680 struct snd_pcm_runtime *runtime,
681 struct urb *urb)
682{
683 int i, stride;
684 unsigned int counts, frames, bytes;
685 unsigned long flags;
686 int period_elapsed = 0;
687 struct snd_urb_ctx *ctx = urb->context;
688
689 stride = runtime->frame_bits >> 3;
690
691 frames = 0;
692 urb->dev = ctx->subs->dev; /* we need to set this at each time */
693 urb->number_of_packets = 0;
694 spin_lock_irqsave(&subs->lock, flags);
695 for (i = 0; i < ctx->packets; i++) {
696 counts = snd_usb_audio_next_packet_size(subs);
697 /* set up descriptor */
698 urb->iso_frame_desc[i].offset = frames * stride;
699 urb->iso_frame_desc[i].length = counts * stride;
700 frames += counts;
701 urb->number_of_packets++;
702 subs->transfer_done += counts;
703 if (subs->transfer_done >= runtime->period_size) {
704 subs->transfer_done -= runtime->period_size;
705 period_elapsed = 1;
706 if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
707 if (subs->transfer_done > 0) {
708 /* FIXME: fill-max mode is not
709 * supported yet */
710 frames -= subs->transfer_done;
711 counts -= subs->transfer_done;
712 urb->iso_frame_desc[i].length =
713 counts * stride;
714 subs->transfer_done = 0;
715 }
716 i++;
717 if (i < ctx->packets) {
718 /* add a transfer delimiter */
719 urb->iso_frame_desc[i].offset =
720 frames * stride;
721 urb->iso_frame_desc[i].length = 0;
722 urb->number_of_packets++;
723 }
724 break;
725 }
726 }
727 if (period_elapsed) /* finish at the period boundary */
728 break;
729 }
730 bytes = frames * stride;
731 if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
732 /* err, the transferred area goes over buffer boundary. */
733 unsigned int bytes1 =
734 runtime->buffer_size * stride - subs->hwptr_done;
735 memcpy(urb->transfer_buffer,
736 runtime->dma_area + subs->hwptr_done, bytes1);
737 memcpy(urb->transfer_buffer + bytes1,
738 runtime->dma_area, bytes - bytes1);
739 } else {
740 memcpy(urb->transfer_buffer,
741 runtime->dma_area + subs->hwptr_done, bytes);
742 }
743 subs->hwptr_done += bytes;
744 if (subs->hwptr_done >= runtime->buffer_size * stride)
745 subs->hwptr_done -= runtime->buffer_size * stride;
746 runtime->delay += frames;
747 spin_unlock_irqrestore(&subs->lock, flags);
748 urb->transfer_buffer_length = bytes;
749 if (period_elapsed)
750 snd_pcm_period_elapsed(subs->pcm_substream);
751 return 0;
752}
753
754/*
755 * process after playback data complete
756 * - decrease the delay count again
757 */
758static int retire_playback_urb(struct snd_usb_substream *subs,
759 struct snd_pcm_runtime *runtime,
760 struct urb *urb)
761{
762 unsigned long flags;
763 int stride = runtime->frame_bits >> 3;
764 int processed = urb->transfer_buffer_length / stride;
765
766 spin_lock_irqsave(&subs->lock, flags);
767 if (processed > runtime->delay)
768 runtime->delay = 0;
769 else
770 runtime->delay -= processed;
771 spin_unlock_irqrestore(&subs->lock, flags);
772 return 0;
773}
774
775static const char *usb_error_string(int err)
776{
777 switch (err) {
778 case -ENODEV:
779 return "no device";
780 case -ENOENT:
781 return "endpoint not enabled";
782 case -EPIPE:
783 return "endpoint stalled";
784 case -ENOSPC:
785 return "not enough bandwidth";
786 case -ESHUTDOWN:
787 return "device disabled";
788 case -EHOSTUNREACH:
789 return "device suspended";
790 case -EINVAL:
791 case -EAGAIN:
792 case -EFBIG:
793 case -EMSGSIZE:
794 return "internal error";
795 default:
796 return "unknown error";
797 }
798}
799
800/*
801 * set up and start data/sync urbs
802 */
803static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime)
804{
805 unsigned int i;
806 int err;
807
808 if (subs->stream->chip->shutdown)
809 return -EBADFD;
810
811 for (i = 0; i < subs->nurbs; i++) {
812 if (snd_BUG_ON(!subs->dataurb[i].urb))
813 return -EINVAL;
814 if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
815 snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
816 goto __error;
817 }
818 }
819 if (subs->syncpipe) {
820 for (i = 0; i < SYNC_URBS; i++) {
821 if (snd_BUG_ON(!subs->syncurb[i].urb))
822 return -EINVAL;
823 if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
824 snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
825 goto __error;
826 }
827 }
828 }
829
830 subs->active_mask = 0;
831 subs->unlink_mask = 0;
832 subs->running = 1;
833 for (i = 0; i < subs->nurbs; i++) {
834 err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC);
835 if (err < 0) {
836 snd_printk(KERN_ERR "cannot submit datapipe "
837 "for urb %d, error %d: %s\n",
838 i, err, usb_error_string(err));
839 goto __error;
840 }
841 set_bit(i, &subs->active_mask);
842 }
843 if (subs->syncpipe) {
844 for (i = 0; i < SYNC_URBS; i++) {
845 err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC);
846 if (err < 0) {
847 snd_printk(KERN_ERR "cannot submit syncpipe "
848 "for urb %d, error %d: %s\n",
849 i, err, usb_error_string(err));
850 goto __error;
851 }
852 set_bit(i + 16, &subs->active_mask);
853 }
854 }
855 return 0;
856
857 __error:
858 // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
859 deactivate_urbs(subs, 0, 0);
860 return -EPIPE;
861}
862
863
864/*
865 */
866static struct snd_urb_ops audio_urb_ops[2] = {
867 {
868 .prepare = prepare_nodata_playback_urb,
869 .retire = retire_playback_urb,
870 .prepare_sync = prepare_playback_sync_urb,
871 .retire_sync = retire_playback_sync_urb,
872 },
873 {
874 .prepare = prepare_capture_urb,
875 .retire = retire_capture_urb,
876 .prepare_sync = prepare_capture_sync_urb,
877 .retire_sync = retire_capture_sync_urb,
878 },
879};
880
881static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
882 {
883 .prepare = prepare_nodata_playback_urb,
884 .retire = retire_playback_urb,
885 .prepare_sync = prepare_playback_sync_urb_hs,
886 .retire_sync = retire_playback_sync_urb_hs,
887 },
888 {
889 .prepare = prepare_capture_urb,
890 .retire = retire_capture_urb,
891 .prepare_sync = prepare_capture_sync_urb_hs,
892 .retire_sync = retire_capture_sync_urb,
893 },
894};
895
896/*
897 * initialize the substream instance.
898 */
899
900void snd_usb_init_substream(struct snd_usb_stream *as,
901 int stream, struct audioformat *fp)
902{
903 struct snd_usb_substream *subs = &as->substream[stream];
904
905 INIT_LIST_HEAD(&subs->fmt_list);
906 spin_lock_init(&subs->lock);
907
908 subs->stream = as;
909 subs->direction = stream;
910 subs->dev = as->chip->dev;
911 subs->txfr_quirk = as->chip->txfr_quirk;
912 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) {
913 subs->ops = audio_urb_ops[stream];
914 } else {
915 subs->ops = audio_urb_ops_high_speed[stream];
916 switch (as->chip->usb_id) {
917 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
918 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
919 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
920 subs->ops.retire_sync = retire_playback_sync_urb_hs_emu;
921 break;
922 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */
923 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
924 subs->ops.prepare_sync = prepare_playback_sync_urb;
925 subs->ops.retire_sync = retire_playback_sync_urb;
926 break;
927 }
928 }
929
930 snd_usb_set_pcm_ops(as->pcm, stream);
931
932 list_add_tail(&fp->list, &subs->fmt_list);
933 subs->formats |= fp->formats;
934 subs->endpoint = fp->endpoint;
935 subs->num_formats++;
936 subs->fmt_type = fp->fmt_type;
937}
938
939int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, int cmd)
940{
941 struct snd_usb_substream *subs = substream->runtime->private_data;
942
943 switch (cmd) {
944 case SNDRV_PCM_TRIGGER_START:
945 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
946 subs->ops.prepare = prepare_playback_urb;
947 return 0;
948 case SNDRV_PCM_TRIGGER_STOP:
949 return deactivate_urbs(subs, 0, 0);
950 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
951 subs->ops.prepare = prepare_nodata_playback_urb;
952 return 0;
953 }
954
955 return -EINVAL;
956}
957
958int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd)
959{
960 struct snd_usb_substream *subs = substream->runtime->private_data;
961
962 switch (cmd) {
963 case SNDRV_PCM_TRIGGER_START:
964 subs->ops.retire = retire_capture_urb;
965 return start_urbs(subs, substream->runtime);
966 case SNDRV_PCM_TRIGGER_STOP:
967 return deactivate_urbs(subs, 0, 0);
968 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
969 subs->ops.retire = retire_paused_capture_urb;
970 return 0;
971 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
972 subs->ops.retire = retire_capture_urb;
973 return 0;
974 }
975
976 return -EINVAL;
977}
978
979int snd_usb_substream_prepare(struct snd_usb_substream *subs,
980 struct snd_pcm_runtime *runtime)
981{
982 /* clear urbs (to be sure) */
983 deactivate_urbs(subs, 0, 1);
984 wait_clear_urbs(subs);
985
986 /* for playback, submit the URBs now; otherwise, the first hwptr_done
987 * updates for all URBs would happen at the same time when starting */
988 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
989 subs->ops.prepare = prepare_nodata_playback_urb;
990 return start_urbs(subs, runtime);
991 }
992
993 return 0;
994}
995
diff --git a/sound/usb/urb.h b/sound/usb/urb.h
new file mode 100644
index 000000000000..888da38079cf
--- /dev/null
+++ b/sound/usb/urb.h
@@ -0,0 +1,21 @@
1#ifndef __USBAUDIO_URB_H
2#define __USBAUDIO_URB_H
3
4void snd_usb_init_substream(struct snd_usb_stream *as,
5 int stream,
6 struct audioformat *fp);
7
8int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
9 unsigned int period_bytes,
10 unsigned int rate,
11 unsigned int frame_bits);
12
13void snd_usb_release_substream_urbs(struct snd_usb_substream *subs, int force);
14
15int snd_usb_substream_prepare(struct snd_usb_substream *subs,
16 struct snd_pcm_runtime *runtime);
17
18int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, int cmd);
19int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd);
20
21#endif /* __USBAUDIO_URB_H */
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
deleted file mode 100644
index 11b0826b8fe6..000000000000
--- a/sound/usb/usbaudio.c
+++ /dev/null
@@ -1,4050 +0,0 @@
1/*
2 * (Tentative) USB Audio Driver for ALSA
3 *
4 * Main and PCM part
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 * NOTES:
29 *
30 * - async unlink should be used for avoiding the sleep inside lock.
31 * 2.4.22 usb-uhci seems buggy for async unlinking and results in
32 * oops. in such a cse, pass async_unlink=0 option.
33 * - the linked URBs would be preferred but not used so far because of
34 * the instability of unlinking.
35 * - type II is not supported properly. there is no device which supports
36 * this type *correctly*. SB extigy looks as if it supports, but it's
37 * indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
38 */
39
40
41#include <linux/bitops.h>
42#include <linux/init.h>
43#include <linux/list.h>
44#include <linux/slab.h>
45#include <linux/string.h>
46#include <linux/usb.h>
47#include <linux/moduleparam.h>
48#include <linux/mutex.h>
49#include <linux/usb/audio.h>
50#include <linux/usb/ch9.h>
51
52#include <sound/core.h>
53#include <sound/info.h>
54#include <sound/pcm.h>
55#include <sound/pcm_params.h>
56#include <sound/initval.h>
57
58#include "usbaudio.h"
59
60
61MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
62MODULE_DESCRIPTION("USB Audio");
63MODULE_LICENSE("GPL");
64MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
65
66
67static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
68static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
69static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
70/* Vendor/product IDs for this card */
71static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
72static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
73static int nrpacks = 8; /* max. number of packets per urb */
74static int async_unlink = 1;
75static int device_setup[SNDRV_CARDS]; /* device parameter for this card*/
76static int ignore_ctl_error;
77
78module_param_array(index, int, NULL, 0444);
79MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
80module_param_array(id, charp, NULL, 0444);
81MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
82module_param_array(enable, bool, NULL, 0444);
83MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
84module_param_array(vid, int, NULL, 0444);
85MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
86module_param_array(pid, int, NULL, 0444);
87MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
88module_param(nrpacks, int, 0644);
89MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
90module_param(async_unlink, bool, 0444);
91MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
92module_param_array(device_setup, int, NULL, 0444);
93MODULE_PARM_DESC(device_setup, "Specific device setup (if needed).");
94module_param(ignore_ctl_error, bool, 0444);
95MODULE_PARM_DESC(ignore_ctl_error,
96 "Ignore errors from USB controller for mixer interfaces.");
97
98/*
99 * debug the h/w constraints
100 */
101/* #define HW_CONST_DEBUG */
102
103
104/*
105 *
106 */
107
108#define MAX_PACKS 20
109#define MAX_PACKS_HS (MAX_PACKS * 8) /* in high speed mode */
110#define MAX_URBS 8
111#define SYNC_URBS 4 /* always four urbs for sync */
112#define MAX_QUEUE 24 /* try not to exceed this queue length, in ms */
113
114struct audioformat {
115 struct list_head list;
116 snd_pcm_format_t format; /* format type */
117 unsigned int channels; /* # channels */
118 unsigned int fmt_type; /* USB audio format type (1-3) */
119 unsigned int frame_size; /* samples per frame for non-audio */
120 int iface; /* interface number */
121 unsigned char altsetting; /* corresponding alternate setting */
122 unsigned char altset_idx; /* array index of altenate setting */
123 unsigned char attributes; /* corresponding attributes of cs endpoint */
124 unsigned char endpoint; /* endpoint */
125 unsigned char ep_attr; /* endpoint attributes */
126 unsigned char datainterval; /* log_2 of data packet interval */
127 unsigned int maxpacksize; /* max. packet size */
128 unsigned int rates; /* rate bitmasks */
129 unsigned int rate_min, rate_max; /* min/max rates */
130 unsigned int nr_rates; /* number of rate table entries */
131 unsigned int *rate_table; /* rate table */
132};
133
134struct snd_usb_substream;
135
136struct snd_urb_ctx {
137 struct urb *urb;
138 unsigned int buffer_size; /* size of data buffer, if data URB */
139 struct snd_usb_substream *subs;
140 int index; /* index for urb array */
141 int packets; /* number of packets per urb */
142};
143
144struct snd_urb_ops {
145 int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
146 int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
147 int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
148 int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
149};
150
151struct snd_usb_substream {
152 struct snd_usb_stream *stream;
153 struct usb_device *dev;
154 struct snd_pcm_substream *pcm_substream;
155 int direction; /* playback or capture */
156 int interface; /* current interface */
157 int endpoint; /* assigned endpoint */
158 struct audioformat *cur_audiofmt; /* current audioformat pointer (for hw_params callback) */
159 unsigned int cur_rate; /* current rate (for hw_params callback) */
160 unsigned int period_bytes; /* current period bytes (for hw_params callback) */
161 unsigned int format; /* USB data format */
162 unsigned int datapipe; /* the data i/o pipe */
163 unsigned int syncpipe; /* 1 - async out or adaptive in */
164 unsigned int datainterval; /* log_2 of data packet interval */
165 unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */
166 unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */
167 unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */
168 unsigned int freqmax; /* maximum sampling rate, used for buffer management */
169 unsigned int phase; /* phase accumulator */
170 unsigned int maxpacksize; /* max packet size in bytes */
171 unsigned int maxframesize; /* max packet size in frames */
172 unsigned int curpacksize; /* current packet size in bytes (for capture) */
173 unsigned int curframesize; /* current packet size in frames (for capture) */
174 unsigned int fill_max: 1; /* fill max packet size always */
175 unsigned int txfr_quirk:1; /* allow sub-frame alignment */
176 unsigned int fmt_type; /* USB audio format type (1-3) */
177
178 unsigned int running: 1; /* running status */
179
180 unsigned int hwptr_done; /* processed byte position in the buffer */
181 unsigned int transfer_done; /* processed frames since last period update */
182 unsigned long active_mask; /* bitmask of active urbs */
183 unsigned long unlink_mask; /* bitmask of unlinked urbs */
184
185 unsigned int nurbs; /* # urbs */
186 struct snd_urb_ctx dataurb[MAX_URBS]; /* data urb table */
187 struct snd_urb_ctx syncurb[SYNC_URBS]; /* sync urb table */
188 char *syncbuf; /* sync buffer for all sync URBs */
189 dma_addr_t sync_dma; /* DMA address of syncbuf */
190
191 u64 formats; /* format bitmasks (all or'ed) */
192 unsigned int num_formats; /* number of supported audio formats (list) */
193 struct list_head fmt_list; /* format list */
194 struct snd_pcm_hw_constraint_list rate_list; /* limited rates */
195 spinlock_t lock;
196
197 struct snd_urb_ops ops; /* callbacks (must be filled at init) */
198};
199
200
201struct snd_usb_stream {
202 struct snd_usb_audio *chip;
203 struct snd_pcm *pcm;
204 int pcm_index;
205 unsigned int fmt_type; /* USB audio format type (1-3) */
206 struct snd_usb_substream substream[2];
207 struct list_head list;
208};
209
210
211/*
212 * we keep the snd_usb_audio_t instances by ourselves for merging
213 * the all interfaces on the same card as one sound device.
214 */
215
216static DEFINE_MUTEX(register_mutex);
217static struct snd_usb_audio *usb_chip[SNDRV_CARDS];
218
219
220/*
221 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
222 * this will overflow at approx 524 kHz
223 */
224static inline unsigned get_usb_full_speed_rate(unsigned int rate)
225{
226 return ((rate << 13) + 62) / 125;
227}
228
229/*
230 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
231 * this will overflow at approx 4 MHz
232 */
233static inline unsigned get_usb_high_speed_rate(unsigned int rate)
234{
235 return ((rate << 10) + 62) / 125;
236}
237
238/* convert our full speed USB rate into sampling rate in Hz */
239static inline unsigned get_full_speed_hz(unsigned int usb_rate)
240{
241 return (usb_rate * 125 + (1 << 12)) >> 13;
242}
243
244/* convert our high speed USB rate into sampling rate in Hz */
245static inline unsigned get_high_speed_hz(unsigned int usb_rate)
246{
247 return (usb_rate * 125 + (1 << 9)) >> 10;
248}
249
250
251/*
252 * prepare urb for full speed capture sync pipe
253 *
254 * fill the length and offset of each urb descriptor.
255 * the fixed 10.14 frequency is passed through the pipe.
256 */
257static int prepare_capture_sync_urb(struct snd_usb_substream *subs,
258 struct snd_pcm_runtime *runtime,
259 struct urb *urb)
260{
261 unsigned char *cp = urb->transfer_buffer;
262 struct snd_urb_ctx *ctx = urb->context;
263
264 urb->dev = ctx->subs->dev; /* we need to set this at each time */
265 urb->iso_frame_desc[0].length = 3;
266 urb->iso_frame_desc[0].offset = 0;
267 cp[0] = subs->freqn >> 2;
268 cp[1] = subs->freqn >> 10;
269 cp[2] = subs->freqn >> 18;
270 return 0;
271}
272
273/*
274 * prepare urb for high speed capture sync pipe
275 *
276 * fill the length and offset of each urb descriptor.
277 * the fixed 12.13 frequency is passed as 16.16 through the pipe.
278 */
279static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs,
280 struct snd_pcm_runtime *runtime,
281 struct urb *urb)
282{
283 unsigned char *cp = urb->transfer_buffer;
284 struct snd_urb_ctx *ctx = urb->context;
285
286 urb->dev = ctx->subs->dev; /* we need to set this at each time */
287 urb->iso_frame_desc[0].length = 4;
288 urb->iso_frame_desc[0].offset = 0;
289 cp[0] = subs->freqn;
290 cp[1] = subs->freqn >> 8;
291 cp[2] = subs->freqn >> 16;
292 cp[3] = subs->freqn >> 24;
293 return 0;
294}
295
296/*
297 * process after capture sync complete
298 * - nothing to do
299 */
300static int retire_capture_sync_urb(struct snd_usb_substream *subs,
301 struct snd_pcm_runtime *runtime,
302 struct urb *urb)
303{
304 return 0;
305}
306
307/*
308 * prepare urb for capture data pipe
309 *
310 * fill the offset and length of each descriptor.
311 *
312 * we use a temporary buffer to write the captured data.
313 * since the length of written data is determined by host, we cannot
314 * write onto the pcm buffer directly... the data is thus copied
315 * later at complete callback to the global buffer.
316 */
317static int prepare_capture_urb(struct snd_usb_substream *subs,
318 struct snd_pcm_runtime *runtime,
319 struct urb *urb)
320{
321 int i, offs;
322 struct snd_urb_ctx *ctx = urb->context;
323
324 offs = 0;
325 urb->dev = ctx->subs->dev; /* we need to set this at each time */
326 for (i = 0; i < ctx->packets; i++) {
327 urb->iso_frame_desc[i].offset = offs;
328 urb->iso_frame_desc[i].length = subs->curpacksize;
329 offs += subs->curpacksize;
330 }
331 urb->transfer_buffer_length = offs;
332 urb->number_of_packets = ctx->packets;
333 return 0;
334}
335
336/*
337 * process after capture complete
338 *
339 * copy the data from each desctiptor to the pcm buffer, and
340 * update the current position.
341 */
342static int retire_capture_urb(struct snd_usb_substream *subs,
343 struct snd_pcm_runtime *runtime,
344 struct urb *urb)
345{
346 unsigned long flags;
347 unsigned char *cp;
348 int i;
349 unsigned int stride, frames, bytes, oldptr;
350 int period_elapsed = 0;
351
352 stride = runtime->frame_bits >> 3;
353
354 for (i = 0; i < urb->number_of_packets; i++) {
355 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
356 if (urb->iso_frame_desc[i].status) {
357 snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
358 // continue;
359 }
360 bytes = urb->iso_frame_desc[i].actual_length;
361 frames = bytes / stride;
362 if (!subs->txfr_quirk)
363 bytes = frames * stride;
364 if (bytes % (runtime->sample_bits >> 3) != 0) {
365#ifdef CONFIG_SND_DEBUG_VERBOSE
366 int oldbytes = bytes;
367#endif
368 bytes = frames * stride;
369 snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
370 oldbytes, bytes);
371 }
372 /* update the current pointer */
373 spin_lock_irqsave(&subs->lock, flags);
374 oldptr = subs->hwptr_done;
375 subs->hwptr_done += bytes;
376 if (subs->hwptr_done >= runtime->buffer_size * stride)
377 subs->hwptr_done -= runtime->buffer_size * stride;
378 frames = (bytes + (oldptr % stride)) / stride;
379 subs->transfer_done += frames;
380 if (subs->transfer_done >= runtime->period_size) {
381 subs->transfer_done -= runtime->period_size;
382 period_elapsed = 1;
383 }
384 spin_unlock_irqrestore(&subs->lock, flags);
385 /* copy a data chunk */
386 if (oldptr + bytes > runtime->buffer_size * stride) {
387 unsigned int bytes1 =
388 runtime->buffer_size * stride - oldptr;
389 memcpy(runtime->dma_area + oldptr, cp, bytes1);
390 memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
391 } else {
392 memcpy(runtime->dma_area + oldptr, cp, bytes);
393 }
394 }
395 if (period_elapsed)
396 snd_pcm_period_elapsed(subs->pcm_substream);
397 return 0;
398}
399
400/*
401 * Process after capture complete when paused. Nothing to do.
402 */
403static int retire_paused_capture_urb(struct snd_usb_substream *subs,
404 struct snd_pcm_runtime *runtime,
405 struct urb *urb)
406{
407 return 0;
408}
409
410
411/*
412 * prepare urb for full speed playback sync pipe
413 *
414 * set up the offset and length to receive the current frequency.
415 */
416
417static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
418 struct snd_pcm_runtime *runtime,
419 struct urb *urb)
420{
421 struct snd_urb_ctx *ctx = urb->context;
422
423 urb->dev = ctx->subs->dev; /* we need to set this at each time */
424 urb->iso_frame_desc[0].length = 3;
425 urb->iso_frame_desc[0].offset = 0;
426 return 0;
427}
428
429/*
430 * prepare urb for high speed playback sync pipe
431 *
432 * set up the offset and length to receive the current frequency.
433 */
434
435static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs,
436 struct snd_pcm_runtime *runtime,
437 struct urb *urb)
438{
439 struct snd_urb_ctx *ctx = urb->context;
440
441 urb->dev = ctx->subs->dev; /* we need to set this at each time */
442 urb->iso_frame_desc[0].length = 4;
443 urb->iso_frame_desc[0].offset = 0;
444 return 0;
445}
446
447/*
448 * process after full speed playback sync complete
449 *
450 * retrieve the current 10.14 frequency from pipe, and set it.
451 * the value is referred in prepare_playback_urb().
452 */
453static int retire_playback_sync_urb(struct snd_usb_substream *subs,
454 struct snd_pcm_runtime *runtime,
455 struct urb *urb)
456{
457 unsigned int f;
458 unsigned long flags;
459
460 if (urb->iso_frame_desc[0].status == 0 &&
461 urb->iso_frame_desc[0].actual_length == 3) {
462 f = combine_triple((u8*)urb->transfer_buffer) << 2;
463 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
464 spin_lock_irqsave(&subs->lock, flags);
465 subs->freqm = f;
466 spin_unlock_irqrestore(&subs->lock, flags);
467 }
468 }
469
470 return 0;
471}
472
473/*
474 * process after high speed playback sync complete
475 *
476 * retrieve the current 12.13 frequency from pipe, and set it.
477 * the value is referred in prepare_playback_urb().
478 */
479static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs,
480 struct snd_pcm_runtime *runtime,
481 struct urb *urb)
482{
483 unsigned int f;
484 unsigned long flags;
485
486 if (urb->iso_frame_desc[0].status == 0 &&
487 urb->iso_frame_desc[0].actual_length == 4) {
488 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
489 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
490 spin_lock_irqsave(&subs->lock, flags);
491 subs->freqm = f;
492 spin_unlock_irqrestore(&subs->lock, flags);
493 }
494 }
495
496 return 0;
497}
498
499/*
500 * process after E-Mu 0202/0404/Tracker Pre high speed playback sync complete
501 *
502 * These devices return the number of samples per packet instead of the number
503 * of samples per microframe.
504 */
505static int retire_playback_sync_urb_hs_emu(struct snd_usb_substream *subs,
506 struct snd_pcm_runtime *runtime,
507 struct urb *urb)
508{
509 unsigned int f;
510 unsigned long flags;
511
512 if (urb->iso_frame_desc[0].status == 0 &&
513 urb->iso_frame_desc[0].actual_length == 4) {
514 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
515 f >>= subs->datainterval;
516 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
517 spin_lock_irqsave(&subs->lock, flags);
518 subs->freqm = f;
519 spin_unlock_irqrestore(&subs->lock, flags);
520 }
521 }
522
523 return 0;
524}
525
526/* determine the number of frames in the next packet */
527static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs)
528{
529 if (subs->fill_max)
530 return subs->maxframesize;
531 else {
532 subs->phase = (subs->phase & 0xffff)
533 + (subs->freqm << subs->datainterval);
534 return min(subs->phase >> 16, subs->maxframesize);
535 }
536}
537
538/*
539 * Prepare urb for streaming before playback starts or when paused.
540 *
541 * We don't have any data, so we send silence.
542 */
543static int prepare_nodata_playback_urb(struct snd_usb_substream *subs,
544 struct snd_pcm_runtime *runtime,
545 struct urb *urb)
546{
547 unsigned int i, offs, counts;
548 struct snd_urb_ctx *ctx = urb->context;
549 int stride = runtime->frame_bits >> 3;
550
551 offs = 0;
552 urb->dev = ctx->subs->dev;
553 for (i = 0; i < ctx->packets; ++i) {
554 counts = snd_usb_audio_next_packet_size(subs);
555 urb->iso_frame_desc[i].offset = offs * stride;
556 urb->iso_frame_desc[i].length = counts * stride;
557 offs += counts;
558 }
559 urb->number_of_packets = ctx->packets;
560 urb->transfer_buffer_length = offs * stride;
561 memset(urb->transfer_buffer,
562 subs->cur_audiofmt->format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0,
563 offs * stride);
564 return 0;
565}
566
567/*
568 * prepare urb for playback data pipe
569 *
570 * Since a URB can handle only a single linear buffer, we must use double
571 * buffering when the data to be transferred overflows the buffer boundary.
572 * To avoid inconsistencies when updating hwptr_done, we use double buffering
573 * for all URBs.
574 */
575static int prepare_playback_urb(struct snd_usb_substream *subs,
576 struct snd_pcm_runtime *runtime,
577 struct urb *urb)
578{
579 int i, stride;
580 unsigned int counts, frames, bytes;
581 unsigned long flags;
582 int period_elapsed = 0;
583 struct snd_urb_ctx *ctx = urb->context;
584
585 stride = runtime->frame_bits >> 3;
586
587 frames = 0;
588 urb->dev = ctx->subs->dev; /* we need to set this at each time */
589 urb->number_of_packets = 0;
590 spin_lock_irqsave(&subs->lock, flags);
591 for (i = 0; i < ctx->packets; i++) {
592 counts = snd_usb_audio_next_packet_size(subs);
593 /* set up descriptor */
594 urb->iso_frame_desc[i].offset = frames * stride;
595 urb->iso_frame_desc[i].length = counts * stride;
596 frames += counts;
597 urb->number_of_packets++;
598 subs->transfer_done += counts;
599 if (subs->transfer_done >= runtime->period_size) {
600 subs->transfer_done -= runtime->period_size;
601 period_elapsed = 1;
602 if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
603 if (subs->transfer_done > 0) {
604 /* FIXME: fill-max mode is not
605 * supported yet */
606 frames -= subs->transfer_done;
607 counts -= subs->transfer_done;
608 urb->iso_frame_desc[i].length =
609 counts * stride;
610 subs->transfer_done = 0;
611 }
612 i++;
613 if (i < ctx->packets) {
614 /* add a transfer delimiter */
615 urb->iso_frame_desc[i].offset =
616 frames * stride;
617 urb->iso_frame_desc[i].length = 0;
618 urb->number_of_packets++;
619 }
620 break;
621 }
622 }
623 if (period_elapsed) /* finish at the period boundary */
624 break;
625 }
626 bytes = frames * stride;
627 if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
628 /* err, the transferred area goes over buffer boundary. */
629 unsigned int bytes1 =
630 runtime->buffer_size * stride - subs->hwptr_done;
631 memcpy(urb->transfer_buffer,
632 runtime->dma_area + subs->hwptr_done, bytes1);
633 memcpy(urb->transfer_buffer + bytes1,
634 runtime->dma_area, bytes - bytes1);
635 } else {
636 memcpy(urb->transfer_buffer,
637 runtime->dma_area + subs->hwptr_done, bytes);
638 }
639 subs->hwptr_done += bytes;
640 if (subs->hwptr_done >= runtime->buffer_size * stride)
641 subs->hwptr_done -= runtime->buffer_size * stride;
642 runtime->delay += frames;
643 spin_unlock_irqrestore(&subs->lock, flags);
644 urb->transfer_buffer_length = bytes;
645 if (period_elapsed)
646 snd_pcm_period_elapsed(subs->pcm_substream);
647 return 0;
648}
649
650/*
651 * process after playback data complete
652 * - decrease the delay count again
653 */
654static int retire_playback_urb(struct snd_usb_substream *subs,
655 struct snd_pcm_runtime *runtime,
656 struct urb *urb)
657{
658 unsigned long flags;
659 int stride = runtime->frame_bits >> 3;
660 int processed = urb->transfer_buffer_length / stride;
661
662 spin_lock_irqsave(&subs->lock, flags);
663 if (processed > runtime->delay)
664 runtime->delay = 0;
665 else
666 runtime->delay -= processed;
667 spin_unlock_irqrestore(&subs->lock, flags);
668 return 0;
669}
670
671
672/*
673 */
674static struct snd_urb_ops audio_urb_ops[2] = {
675 {
676 .prepare = prepare_nodata_playback_urb,
677 .retire = retire_playback_urb,
678 .prepare_sync = prepare_playback_sync_urb,
679 .retire_sync = retire_playback_sync_urb,
680 },
681 {
682 .prepare = prepare_capture_urb,
683 .retire = retire_capture_urb,
684 .prepare_sync = prepare_capture_sync_urb,
685 .retire_sync = retire_capture_sync_urb,
686 },
687};
688
689static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
690 {
691 .prepare = prepare_nodata_playback_urb,
692 .retire = retire_playback_urb,
693 .prepare_sync = prepare_playback_sync_urb_hs,
694 .retire_sync = retire_playback_sync_urb_hs,
695 },
696 {
697 .prepare = prepare_capture_urb,
698 .retire = retire_capture_urb,
699 .prepare_sync = prepare_capture_sync_urb_hs,
700 .retire_sync = retire_capture_sync_urb,
701 },
702};
703
704/*
705 * complete callback from data urb
706 */
707static void snd_complete_urb(struct urb *urb)
708{
709 struct snd_urb_ctx *ctx = urb->context;
710 struct snd_usb_substream *subs = ctx->subs;
711 struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
712 int err = 0;
713
714 if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
715 !subs->running || /* can be stopped during retire callback */
716 (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
717 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
718 clear_bit(ctx->index, &subs->active_mask);
719 if (err < 0) {
720 snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
721 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
722 }
723 }
724}
725
726
727/*
728 * complete callback from sync urb
729 */
730static void snd_complete_sync_urb(struct urb *urb)
731{
732 struct snd_urb_ctx *ctx = urb->context;
733 struct snd_usb_substream *subs = ctx->subs;
734 struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
735 int err = 0;
736
737 if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
738 !subs->running || /* can be stopped during retire callback */
739 (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
740 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
741 clear_bit(ctx->index + 16, &subs->active_mask);
742 if (err < 0) {
743 snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
744 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
745 }
746 }
747}
748
749
750/*
751 * unlink active urbs.
752 */
753static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep)
754{
755 unsigned int i;
756 int async;
757
758 subs->running = 0;
759
760 if (!force && subs->stream->chip->shutdown) /* to be sure... */
761 return -EBADFD;
762
763 async = !can_sleep && async_unlink;
764
765 if (!async && in_interrupt())
766 return 0;
767
768 for (i = 0; i < subs->nurbs; i++) {
769 if (test_bit(i, &subs->active_mask)) {
770 if (!test_and_set_bit(i, &subs->unlink_mask)) {
771 struct urb *u = subs->dataurb[i].urb;
772 if (async)
773 usb_unlink_urb(u);
774 else
775 usb_kill_urb(u);
776 }
777 }
778 }
779 if (subs->syncpipe) {
780 for (i = 0; i < SYNC_URBS; i++) {
781 if (test_bit(i+16, &subs->active_mask)) {
782 if (!test_and_set_bit(i+16, &subs->unlink_mask)) {
783 struct urb *u = subs->syncurb[i].urb;
784 if (async)
785 usb_unlink_urb(u);
786 else
787 usb_kill_urb(u);
788 }
789 }
790 }
791 }
792 return 0;
793}
794
795
796static const char *usb_error_string(int err)
797{
798 switch (err) {
799 case -ENODEV:
800 return "no device";
801 case -ENOENT:
802 return "endpoint not enabled";
803 case -EPIPE:
804 return "endpoint stalled";
805 case -ENOSPC:
806 return "not enough bandwidth";
807 case -ESHUTDOWN:
808 return "device disabled";
809 case -EHOSTUNREACH:
810 return "device suspended";
811 case -EINVAL:
812 case -EAGAIN:
813 case -EFBIG:
814 case -EMSGSIZE:
815 return "internal error";
816 default:
817 return "unknown error";
818 }
819}
820
821/*
822 * set up and start data/sync urbs
823 */
824static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime)
825{
826 unsigned int i;
827 int err;
828
829 if (subs->stream->chip->shutdown)
830 return -EBADFD;
831
832 for (i = 0; i < subs->nurbs; i++) {
833 if (snd_BUG_ON(!subs->dataurb[i].urb))
834 return -EINVAL;
835 if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
836 snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
837 goto __error;
838 }
839 }
840 if (subs->syncpipe) {
841 for (i = 0; i < SYNC_URBS; i++) {
842 if (snd_BUG_ON(!subs->syncurb[i].urb))
843 return -EINVAL;
844 if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
845 snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
846 goto __error;
847 }
848 }
849 }
850
851 subs->active_mask = 0;
852 subs->unlink_mask = 0;
853 subs->running = 1;
854 for (i = 0; i < subs->nurbs; i++) {
855 err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC);
856 if (err < 0) {
857 snd_printk(KERN_ERR "cannot submit datapipe "
858 "for urb %d, error %d: %s\n",
859 i, err, usb_error_string(err));
860 goto __error;
861 }
862 set_bit(i, &subs->active_mask);
863 }
864 if (subs->syncpipe) {
865 for (i = 0; i < SYNC_URBS; i++) {
866 err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC);
867 if (err < 0) {
868 snd_printk(KERN_ERR "cannot submit syncpipe "
869 "for urb %d, error %d: %s\n",
870 i, err, usb_error_string(err));
871 goto __error;
872 }
873 set_bit(i + 16, &subs->active_mask);
874 }
875 }
876 return 0;
877
878 __error:
879 // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
880 deactivate_urbs(subs, 0, 0);
881 return -EPIPE;
882}
883
884
885/*
886 * wait until all urbs are processed.
887 */
888static int wait_clear_urbs(struct snd_usb_substream *subs)
889{
890 unsigned long end_time = jiffies + msecs_to_jiffies(1000);
891 unsigned int i;
892 int alive;
893
894 do {
895 alive = 0;
896 for (i = 0; i < subs->nurbs; i++) {
897 if (test_bit(i, &subs->active_mask))
898 alive++;
899 }
900 if (subs->syncpipe) {
901 for (i = 0; i < SYNC_URBS; i++) {
902 if (test_bit(i + 16, &subs->active_mask))
903 alive++;
904 }
905 }
906 if (! alive)
907 break;
908 schedule_timeout_uninterruptible(1);
909 } while (time_before(jiffies, end_time));
910 if (alive)
911 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
912 return 0;
913}
914
915
916/*
917 * return the current pcm pointer. just based on the hwptr_done value.
918 */
919static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
920{
921 struct snd_usb_substream *subs;
922 unsigned int hwptr_done;
923
924 subs = (struct snd_usb_substream *)substream->runtime->private_data;
925 spin_lock(&subs->lock);
926 hwptr_done = subs->hwptr_done;
927 spin_unlock(&subs->lock);
928 return hwptr_done / (substream->runtime->frame_bits >> 3);
929}
930
931
932/*
933 * start/stop playback substream
934 */
935static int snd_usb_pcm_playback_trigger(struct snd_pcm_substream *substream,
936 int cmd)
937{
938 struct snd_usb_substream *subs = substream->runtime->private_data;
939
940 switch (cmd) {
941 case SNDRV_PCM_TRIGGER_START:
942 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
943 subs->ops.prepare = prepare_playback_urb;
944 return 0;
945 case SNDRV_PCM_TRIGGER_STOP:
946 return deactivate_urbs(subs, 0, 0);
947 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
948 subs->ops.prepare = prepare_nodata_playback_urb;
949 return 0;
950 default:
951 return -EINVAL;
952 }
953}
954
955/*
956 * start/stop capture substream
957 */
958static int snd_usb_pcm_capture_trigger(struct snd_pcm_substream *substream,
959 int cmd)
960{
961 struct snd_usb_substream *subs = substream->runtime->private_data;
962
963 switch (cmd) {
964 case SNDRV_PCM_TRIGGER_START:
965 subs->ops.retire = retire_capture_urb;
966 return start_urbs(subs, substream->runtime);
967 case SNDRV_PCM_TRIGGER_STOP:
968 return deactivate_urbs(subs, 0, 0);
969 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
970 subs->ops.retire = retire_paused_capture_urb;
971 return 0;
972 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
973 subs->ops.retire = retire_capture_urb;
974 return 0;
975 default:
976 return -EINVAL;
977 }
978}
979
980
981/*
982 * release a urb data
983 */
984static void release_urb_ctx(struct snd_urb_ctx *u)
985{
986 if (u->urb) {
987 if (u->buffer_size)
988 usb_buffer_free(u->subs->dev, u->buffer_size,
989 u->urb->transfer_buffer,
990 u->urb->transfer_dma);
991 usb_free_urb(u->urb);
992 u->urb = NULL;
993 }
994}
995
996/*
997 * release a substream
998 */
999static void release_substream_urbs(struct snd_usb_substream *subs, int force)
1000{
1001 int i;
1002
1003 /* stop urbs (to be sure) */
1004 deactivate_urbs(subs, force, 1);
1005 wait_clear_urbs(subs);
1006
1007 for (i = 0; i < MAX_URBS; i++)
1008 release_urb_ctx(&subs->dataurb[i]);
1009 for (i = 0; i < SYNC_URBS; i++)
1010 release_urb_ctx(&subs->syncurb[i]);
1011 usb_buffer_free(subs->dev, SYNC_URBS * 4,
1012 subs->syncbuf, subs->sync_dma);
1013 subs->syncbuf = NULL;
1014 subs->nurbs = 0;
1015}
1016
1017/*
1018 * initialize a substream for plaback/capture
1019 */
1020static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int period_bytes,
1021 unsigned int rate, unsigned int frame_bits)
1022{
1023 unsigned int maxsize, i;
1024 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1025 unsigned int urb_packs, total_packs, packs_per_ms;
1026
1027 /* calculate the frequency in 16.16 format */
1028 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1029 subs->freqn = get_usb_full_speed_rate(rate);
1030 else
1031 subs->freqn = get_usb_high_speed_rate(rate);
1032 subs->freqm = subs->freqn;
1033 /* calculate max. frequency */
1034 if (subs->maxpacksize) {
1035 /* whatever fits into a max. size packet */
1036 maxsize = subs->maxpacksize;
1037 subs->freqmax = (maxsize / (frame_bits >> 3))
1038 << (16 - subs->datainterval);
1039 } else {
1040 /* no max. packet size: just take 25% higher than nominal */
1041 subs->freqmax = subs->freqn + (subs->freqn >> 2);
1042 maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3))
1043 >> (16 - subs->datainterval);
1044 }
1045 subs->phase = 0;
1046
1047 if (subs->fill_max)
1048 subs->curpacksize = subs->maxpacksize;
1049 else
1050 subs->curpacksize = maxsize;
1051
1052 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
1053 packs_per_ms = 8 >> subs->datainterval;
1054 else
1055 packs_per_ms = 1;
1056
1057 if (is_playback) {
1058 urb_packs = max(nrpacks, 1);
1059 urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
1060 } else
1061 urb_packs = 1;
1062 urb_packs *= packs_per_ms;
1063 if (subs->syncpipe)
1064 urb_packs = min(urb_packs, 1U << subs->syncinterval);
1065
1066 /* decide how many packets to be used */
1067 if (is_playback) {
1068 unsigned int minsize, maxpacks;
1069 /* determine how small a packet can be */
1070 minsize = (subs->freqn >> (16 - subs->datainterval))
1071 * (frame_bits >> 3);
1072 /* with sync from device, assume it can be 12% lower */
1073 if (subs->syncpipe)
1074 minsize -= minsize >> 3;
1075 minsize = max(minsize, 1u);
1076 total_packs = (period_bytes + minsize - 1) / minsize;
1077 /* we need at least two URBs for queueing */
1078 if (total_packs < 2) {
1079 total_packs = 2;
1080 } else {
1081 /* and we don't want too long a queue either */
1082 maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
1083 total_packs = min(total_packs, maxpacks);
1084 }
1085 } else {
1086 while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
1087 urb_packs >>= 1;
1088 total_packs = MAX_URBS * urb_packs;
1089 }
1090 subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
1091 if (subs->nurbs > MAX_URBS) {
1092 /* too much... */
1093 subs->nurbs = MAX_URBS;
1094 total_packs = MAX_URBS * urb_packs;
1095 } else if (subs->nurbs < 2) {
1096 /* too little - we need at least two packets
1097 * to ensure contiguous playback/capture
1098 */
1099 subs->nurbs = 2;
1100 }
1101
1102 /* allocate and initialize data urbs */
1103 for (i = 0; i < subs->nurbs; i++) {
1104 struct snd_urb_ctx *u = &subs->dataurb[i];
1105 u->index = i;
1106 u->subs = subs;
1107 u->packets = (i + 1) * total_packs / subs->nurbs
1108 - i * total_packs / subs->nurbs;
1109 u->buffer_size = maxsize * u->packets;
1110 if (subs->fmt_type == UAC_FORMAT_TYPE_II)
1111 u->packets++; /* for transfer delimiter */
1112 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
1113 if (!u->urb)
1114 goto out_of_memory;
1115 u->urb->transfer_buffer =
1116 usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL,
1117 &u->urb->transfer_dma);
1118 if (!u->urb->transfer_buffer)
1119 goto out_of_memory;
1120 u->urb->pipe = subs->datapipe;
1121 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1122 u->urb->interval = 1 << subs->datainterval;
1123 u->urb->context = u;
1124 u->urb->complete = snd_complete_urb;
1125 }
1126
1127 if (subs->syncpipe) {
1128 /* allocate and initialize sync urbs */
1129 subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4,
1130 GFP_KERNEL, &subs->sync_dma);
1131 if (!subs->syncbuf)
1132 goto out_of_memory;
1133 for (i = 0; i < SYNC_URBS; i++) {
1134 struct snd_urb_ctx *u = &subs->syncurb[i];
1135 u->index = i;
1136 u->subs = subs;
1137 u->packets = 1;
1138 u->urb = usb_alloc_urb(1, GFP_KERNEL);
1139 if (!u->urb)
1140 goto out_of_memory;
1141 u->urb->transfer_buffer = subs->syncbuf + i * 4;
1142 u->urb->transfer_dma = subs->sync_dma + i * 4;
1143 u->urb->transfer_buffer_length = 4;
1144 u->urb->pipe = subs->syncpipe;
1145 u->urb->transfer_flags = URB_ISO_ASAP |
1146 URB_NO_TRANSFER_DMA_MAP;
1147 u->urb->number_of_packets = 1;
1148 u->urb->interval = 1 << subs->syncinterval;
1149 u->urb->context = u;
1150 u->urb->complete = snd_complete_sync_urb;
1151 }
1152 }
1153 return 0;
1154
1155out_of_memory:
1156 release_substream_urbs(subs, 0);
1157 return -ENOMEM;
1158}
1159
1160
1161/*
1162 * find a matching audio format
1163 */
1164static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format,
1165 unsigned int rate, unsigned int channels)
1166{
1167 struct list_head *p;
1168 struct audioformat *found = NULL;
1169 int cur_attr = 0, attr;
1170
1171 list_for_each(p, &subs->fmt_list) {
1172 struct audioformat *fp;
1173 fp = list_entry(p, struct audioformat, list);
1174 if (fp->format != format || fp->channels != channels)
1175 continue;
1176 if (rate < fp->rate_min || rate > fp->rate_max)
1177 continue;
1178 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
1179 unsigned int i;
1180 for (i = 0; i < fp->nr_rates; i++)
1181 if (fp->rate_table[i] == rate)
1182 break;
1183 if (i >= fp->nr_rates)
1184 continue;
1185 }
1186 attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
1187 if (! found) {
1188 found = fp;
1189 cur_attr = attr;
1190 continue;
1191 }
1192 /* avoid async out and adaptive in if the other method
1193 * supports the same format.
1194 * this is a workaround for the case like
1195 * M-audio audiophile USB.
1196 */
1197 if (attr != cur_attr) {
1198 if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
1199 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1200 (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
1201 subs->direction == SNDRV_PCM_STREAM_CAPTURE))
1202 continue;
1203 if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
1204 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1205 (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
1206 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
1207 found = fp;
1208 cur_attr = attr;
1209 continue;
1210 }
1211 }
1212 /* find the format with the largest max. packet size */
1213 if (fp->maxpacksize > found->maxpacksize) {
1214 found = fp;
1215 cur_attr = attr;
1216 }
1217 }
1218 return found;
1219}
1220
1221
1222/*
1223 * initialize the picth control and sample rate
1224 */
1225static int init_usb_pitch(struct usb_device *dev, int iface,
1226 struct usb_host_interface *alts,
1227 struct audioformat *fmt)
1228{
1229 unsigned int ep;
1230 unsigned char data[1];
1231 int err;
1232
1233 ep = get_endpoint(alts, 0)->bEndpointAddress;
1234 /* if endpoint has pitch control, enable it */
1235 if (fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL) {
1236 data[0] = 1;
1237 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
1238 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1239 UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
1240 snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
1241 dev->devnum, iface, ep);
1242 return err;
1243 }
1244 }
1245 return 0;
1246}
1247
1248static int init_usb_sample_rate(struct usb_device *dev, int iface,
1249 struct usb_host_interface *alts,
1250 struct audioformat *fmt, int rate)
1251{
1252 unsigned int ep;
1253 unsigned char data[3];
1254 int err;
1255
1256 ep = get_endpoint(alts, 0)->bEndpointAddress;
1257 /* if endpoint has sampling rate control, set it */
1258 if (fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE) {
1259 int crate;
1260 data[0] = rate;
1261 data[1] = rate >> 8;
1262 data[2] = rate >> 16;
1263 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
1264 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1265 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000)) < 0) {
1266 snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
1267 dev->devnum, iface, fmt->altsetting, rate, ep);
1268 return err;
1269 }
1270 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
1271 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1272 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000)) < 0) {
1273 snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
1274 dev->devnum, iface, fmt->altsetting, ep);
1275 return 0; /* some devices don't support reading */
1276 }
1277 crate = data[0] | (data[1] << 8) | (data[2] << 16);
1278 if (crate != rate) {
1279 snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
1280 // runtime->rate = crate;
1281 }
1282 }
1283 return 0;
1284}
1285
1286/*
1287 * For E-Mu 0404USB/0202USB/TrackerPre sample rate should be set for device,
1288 * not for interface.
1289 */
1290static void set_format_emu_quirk(struct snd_usb_substream *subs,
1291 struct audioformat *fmt)
1292{
1293 unsigned char emu_samplerate_id = 0;
1294
1295 /* When capture is active
1296 * sample rate shouldn't be changed
1297 * by playback substream
1298 */
1299 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1300 if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1)
1301 return;
1302 }
1303
1304 switch (fmt->rate_min) {
1305 case 48000:
1306 emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
1307 break;
1308 case 88200:
1309 emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
1310 break;
1311 case 96000:
1312 emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
1313 break;
1314 case 176400:
1315 emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
1316 break;
1317 case 192000:
1318 emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
1319 break;
1320 default:
1321 emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
1322 break;
1323 }
1324 snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
1325}
1326
1327/*
1328 * find a matching format and set up the interface
1329 */
1330static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
1331{
1332 struct usb_device *dev = subs->dev;
1333 struct usb_host_interface *alts;
1334 struct usb_interface_descriptor *altsd;
1335 struct usb_interface *iface;
1336 unsigned int ep, attr;
1337 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1338 int err;
1339
1340 iface = usb_ifnum_to_if(dev, fmt->iface);
1341 if (WARN_ON(!iface))
1342 return -EINVAL;
1343 alts = &iface->altsetting[fmt->altset_idx];
1344 altsd = get_iface_desc(alts);
1345 if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
1346 return -EINVAL;
1347
1348 if (fmt == subs->cur_audiofmt)
1349 return 0;
1350
1351 /* close the old interface */
1352 if (subs->interface >= 0 && subs->interface != fmt->iface) {
1353 if (usb_set_interface(subs->dev, subs->interface, 0) < 0) {
1354 snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed\n",
1355 dev->devnum, fmt->iface, fmt->altsetting);
1356 return -EIO;
1357 }
1358 subs->interface = -1;
1359 subs->format = 0;
1360 }
1361
1362 /* set interface */
1363 if (subs->interface != fmt->iface || subs->format != fmt->altset_idx) {
1364 if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
1365 snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
1366 dev->devnum, fmt->iface, fmt->altsetting);
1367 return -EIO;
1368 }
1369 snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
1370 subs->interface = fmt->iface;
1371 subs->format = fmt->altset_idx;
1372 }
1373
1374 /* create a data pipe */
1375 ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
1376 if (is_playback)
1377 subs->datapipe = usb_sndisocpipe(dev, ep);
1378 else
1379 subs->datapipe = usb_rcvisocpipe(dev, ep);
1380 subs->datainterval = fmt->datainterval;
1381 subs->syncpipe = subs->syncinterval = 0;
1382 subs->maxpacksize = fmt->maxpacksize;
1383 subs->fill_max = 0;
1384
1385 /* we need a sync pipe in async OUT or adaptive IN mode */
1386 /* check the number of EP, since some devices have broken
1387 * descriptors which fool us. if it has only one EP,
1388 * assume it as adaptive-out or sync-in.
1389 */
1390 attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
1391 if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) ||
1392 (! is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
1393 altsd->bNumEndpoints >= 2) {
1394 /* check sync-pipe endpoint */
1395 /* ... and check descriptor size before accessing bSynchAddress
1396 because there is a version of the SB Audigy 2 NX firmware lacking
1397 the audio fields in the endpoint descriptors */
1398 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
1399 (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1400 get_endpoint(alts, 1)->bSynchAddress != 0)) {
1401 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1402 dev->devnum, fmt->iface, fmt->altsetting);
1403 return -EINVAL;
1404 }
1405 ep = get_endpoint(alts, 1)->bEndpointAddress;
1406 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1407 (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
1408 (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
1409 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1410 dev->devnum, fmt->iface, fmt->altsetting);
1411 return -EINVAL;
1412 }
1413 ep &= USB_ENDPOINT_NUMBER_MASK;
1414 if (is_playback)
1415 subs->syncpipe = usb_rcvisocpipe(dev, ep);
1416 else
1417 subs->syncpipe = usb_sndisocpipe(dev, ep);
1418 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1419 get_endpoint(alts, 1)->bRefresh >= 1 &&
1420 get_endpoint(alts, 1)->bRefresh <= 9)
1421 subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
1422 else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1423 subs->syncinterval = 1;
1424 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
1425 get_endpoint(alts, 1)->bInterval <= 16)
1426 subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
1427 else
1428 subs->syncinterval = 3;
1429 }
1430
1431 /* always fill max packet size */
1432 if (fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX)
1433 subs->fill_max = 1;
1434
1435 if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
1436 return err;
1437
1438 subs->cur_audiofmt = fmt;
1439
1440 switch (subs->stream->chip->usb_id) {
1441 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
1442 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
1443 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
1444 set_format_emu_quirk(subs, fmt);
1445 break;
1446 }
1447
1448#if 0
1449 printk(KERN_DEBUG
1450 "setting done: format = %d, rate = %d..%d, channels = %d\n",
1451 fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels);
1452 printk(KERN_DEBUG
1453 " datapipe = 0x%0x, syncpipe = 0x%0x\n",
1454 subs->datapipe, subs->syncpipe);
1455#endif
1456
1457 return 0;
1458}
1459
1460/*
1461 * hw_params callback
1462 *
1463 * allocate a buffer and set the given audio format.
1464 *
1465 * so far we use a physically linear buffer although packetize transfer
1466 * doesn't need a continuous area.
1467 * if sg buffer is supported on the later version of alsa, we'll follow
1468 * that.
1469 */
1470static int snd_usb_hw_params(struct snd_pcm_substream *substream,
1471 struct snd_pcm_hw_params *hw_params)
1472{
1473 struct snd_usb_substream *subs = substream->runtime->private_data;
1474 struct audioformat *fmt;
1475 unsigned int channels, rate, format;
1476 int ret, changed;
1477
1478 ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
1479 params_buffer_bytes(hw_params));
1480 if (ret < 0)
1481 return ret;
1482
1483 format = params_format(hw_params);
1484 rate = params_rate(hw_params);
1485 channels = params_channels(hw_params);
1486 fmt = find_format(subs, format, rate, channels);
1487 if (!fmt) {
1488 snd_printd(KERN_DEBUG "cannot set format: format = %#x, rate = %d, channels = %d\n",
1489 format, rate, channels);
1490 return -EINVAL;
1491 }
1492
1493 changed = subs->cur_audiofmt != fmt ||
1494 subs->period_bytes != params_period_bytes(hw_params) ||
1495 subs->cur_rate != rate;
1496 if ((ret = set_format(subs, fmt)) < 0)
1497 return ret;
1498
1499 if (subs->cur_rate != rate) {
1500 struct usb_host_interface *alts;
1501 struct usb_interface *iface;
1502 iface = usb_ifnum_to_if(subs->dev, fmt->iface);
1503 alts = &iface->altsetting[fmt->altset_idx];
1504 ret = init_usb_sample_rate(subs->dev, subs->interface, alts, fmt, rate);
1505 if (ret < 0)
1506 return ret;
1507 subs->cur_rate = rate;
1508 }
1509
1510 if (changed) {
1511 /* format changed */
1512 release_substream_urbs(subs, 0);
1513 /* influenced: period_bytes, channels, rate, format, */
1514 ret = init_substream_urbs(subs, params_period_bytes(hw_params),
1515 params_rate(hw_params),
1516 snd_pcm_format_physical_width(params_format(hw_params)) * params_channels(hw_params));
1517 }
1518
1519 return ret;
1520}
1521
1522/*
1523 * hw_free callback
1524 *
1525 * reset the audio format and release the buffer
1526 */
1527static int snd_usb_hw_free(struct snd_pcm_substream *substream)
1528{
1529 struct snd_usb_substream *subs = substream->runtime->private_data;
1530
1531 subs->cur_audiofmt = NULL;
1532 subs->cur_rate = 0;
1533 subs->period_bytes = 0;
1534 if (!subs->stream->chip->shutdown)
1535 release_substream_urbs(subs, 0);
1536 return snd_pcm_lib_free_vmalloc_buffer(substream);
1537}
1538
1539/*
1540 * prepare callback
1541 *
1542 * only a few subtle things...
1543 */
1544static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
1545{
1546 struct snd_pcm_runtime *runtime = substream->runtime;
1547 struct snd_usb_substream *subs = runtime->private_data;
1548
1549 if (! subs->cur_audiofmt) {
1550 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
1551 return -ENXIO;
1552 }
1553
1554 /* some unit conversions in runtime */
1555 subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
1556 subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
1557
1558 /* reset the pointer */
1559 subs->hwptr_done = 0;
1560 subs->transfer_done = 0;
1561 subs->phase = 0;
1562 runtime->delay = 0;
1563
1564 /* clear urbs (to be sure) */
1565 deactivate_urbs(subs, 0, 1);
1566 wait_clear_urbs(subs);
1567
1568 /* for playback, submit the URBs now; otherwise, the first hwptr_done
1569 * updates for all URBs would happen at the same time when starting */
1570 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1571 subs->ops.prepare = prepare_nodata_playback_urb;
1572 return start_urbs(subs, runtime);
1573 } else
1574 return 0;
1575}
1576
1577static struct snd_pcm_hardware snd_usb_hardware =
1578{
1579 .info = SNDRV_PCM_INFO_MMAP |
1580 SNDRV_PCM_INFO_MMAP_VALID |
1581 SNDRV_PCM_INFO_BATCH |
1582 SNDRV_PCM_INFO_INTERLEAVED |
1583 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1584 SNDRV_PCM_INFO_PAUSE,
1585 .buffer_bytes_max = 1024 * 1024,
1586 .period_bytes_min = 64,
1587 .period_bytes_max = 512 * 1024,
1588 .periods_min = 2,
1589 .periods_max = 1024,
1590};
1591
1592/*
1593 * h/w constraints
1594 */
1595
1596#ifdef HW_CONST_DEBUG
1597#define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
1598#else
1599#define hwc_debug(fmt, args...) /**/
1600#endif
1601
1602static int hw_check_valid_format(struct snd_usb_substream *subs,
1603 struct snd_pcm_hw_params *params,
1604 struct audioformat *fp)
1605{
1606 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1607 struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1608 struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1609 struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
1610 unsigned int ptime;
1611
1612 /* check the format */
1613 if (!snd_mask_test(fmts, fp->format)) {
1614 hwc_debug(" > check: no supported format %d\n", fp->format);
1615 return 0;
1616 }
1617 /* check the channels */
1618 if (fp->channels < ct->min || fp->channels > ct->max) {
1619 hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
1620 return 0;
1621 }
1622 /* check the rate is within the range */
1623 if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
1624 hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max);
1625 return 0;
1626 }
1627 if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
1628 hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min);
1629 return 0;
1630 }
1631 /* check whether the period time is >= the data packet interval */
1632 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) {
1633 ptime = 125 * (1 << fp->datainterval);
1634 if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
1635 hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max);
1636 return 0;
1637 }
1638 }
1639 return 1;
1640}
1641
1642static int hw_rule_rate(struct snd_pcm_hw_params *params,
1643 struct snd_pcm_hw_rule *rule)
1644{
1645 struct snd_usb_substream *subs = rule->private;
1646 struct list_head *p;
1647 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1648 unsigned int rmin, rmax;
1649 int changed;
1650
1651 hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
1652 changed = 0;
1653 rmin = rmax = 0;
1654 list_for_each(p, &subs->fmt_list) {
1655 struct audioformat *fp;
1656 fp = list_entry(p, struct audioformat, list);
1657 if (!hw_check_valid_format(subs, params, fp))
1658 continue;
1659 if (changed++) {
1660 if (rmin > fp->rate_min)
1661 rmin = fp->rate_min;
1662 if (rmax < fp->rate_max)
1663 rmax = fp->rate_max;
1664 } else {
1665 rmin = fp->rate_min;
1666 rmax = fp->rate_max;
1667 }
1668 }
1669
1670 if (!changed) {
1671 hwc_debug(" --> get empty\n");
1672 it->empty = 1;
1673 return -EINVAL;
1674 }
1675
1676 changed = 0;
1677 if (it->min < rmin) {
1678 it->min = rmin;
1679 it->openmin = 0;
1680 changed = 1;
1681 }
1682 if (it->max > rmax) {
1683 it->max = rmax;
1684 it->openmax = 0;
1685 changed = 1;
1686 }
1687 if (snd_interval_checkempty(it)) {
1688 it->empty = 1;
1689 return -EINVAL;
1690 }
1691 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1692 return changed;
1693}
1694
1695
1696static int hw_rule_channels(struct snd_pcm_hw_params *params,
1697 struct snd_pcm_hw_rule *rule)
1698{
1699 struct snd_usb_substream *subs = rule->private;
1700 struct list_head *p;
1701 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1702 unsigned int rmin, rmax;
1703 int changed;
1704
1705 hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
1706 changed = 0;
1707 rmin = rmax = 0;
1708 list_for_each(p, &subs->fmt_list) {
1709 struct audioformat *fp;
1710 fp = list_entry(p, struct audioformat, list);
1711 if (!hw_check_valid_format(subs, params, fp))
1712 continue;
1713 if (changed++) {
1714 if (rmin > fp->channels)
1715 rmin = fp->channels;
1716 if (rmax < fp->channels)
1717 rmax = fp->channels;
1718 } else {
1719 rmin = fp->channels;
1720 rmax = fp->channels;
1721 }
1722 }
1723
1724 if (!changed) {
1725 hwc_debug(" --> get empty\n");
1726 it->empty = 1;
1727 return -EINVAL;
1728 }
1729
1730 changed = 0;
1731 if (it->min < rmin) {
1732 it->min = rmin;
1733 it->openmin = 0;
1734 changed = 1;
1735 }
1736 if (it->max > rmax) {
1737 it->max = rmax;
1738 it->openmax = 0;
1739 changed = 1;
1740 }
1741 if (snd_interval_checkempty(it)) {
1742 it->empty = 1;
1743 return -EINVAL;
1744 }
1745 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1746 return changed;
1747}
1748
1749static int hw_rule_format(struct snd_pcm_hw_params *params,
1750 struct snd_pcm_hw_rule *rule)
1751{
1752 struct snd_usb_substream *subs = rule->private;
1753 struct list_head *p;
1754 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1755 u64 fbits;
1756 u32 oldbits[2];
1757 int changed;
1758
1759 hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
1760 fbits = 0;
1761 list_for_each(p, &subs->fmt_list) {
1762 struct audioformat *fp;
1763 fp = list_entry(p, struct audioformat, list);
1764 if (!hw_check_valid_format(subs, params, fp))
1765 continue;
1766 fbits |= (1ULL << fp->format);
1767 }
1768
1769 oldbits[0] = fmt->bits[0];
1770 oldbits[1] = fmt->bits[1];
1771 fmt->bits[0] &= (u32)fbits;
1772 fmt->bits[1] &= (u32)(fbits >> 32);
1773 if (!fmt->bits[0] && !fmt->bits[1]) {
1774 hwc_debug(" --> get empty\n");
1775 return -EINVAL;
1776 }
1777 changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
1778 hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
1779 return changed;
1780}
1781
1782static int hw_rule_period_time(struct snd_pcm_hw_params *params,
1783 struct snd_pcm_hw_rule *rule)
1784{
1785 struct snd_usb_substream *subs = rule->private;
1786 struct audioformat *fp;
1787 struct snd_interval *it;
1788 unsigned char min_datainterval;
1789 unsigned int pmin;
1790 int changed;
1791
1792 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
1793 hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max);
1794 min_datainterval = 0xff;
1795 list_for_each_entry(fp, &subs->fmt_list, list) {
1796 if (!hw_check_valid_format(subs, params, fp))
1797 continue;
1798 min_datainterval = min(min_datainterval, fp->datainterval);
1799 }
1800 if (min_datainterval == 0xff) {
1801 hwc_debug(" --> get emtpy\n");
1802 it->empty = 1;
1803 return -EINVAL;
1804 }
1805 pmin = 125 * (1 << min_datainterval);
1806 changed = 0;
1807 if (it->min < pmin) {
1808 it->min = pmin;
1809 it->openmin = 0;
1810 changed = 1;
1811 }
1812 if (snd_interval_checkempty(it)) {
1813 it->empty = 1;
1814 return -EINVAL;
1815 }
1816 hwc_debug(" --> (%u,%u) (changed = %d)\n", it->min, it->max, changed);
1817 return changed;
1818}
1819
1820/*
1821 * If the device supports unusual bit rates, does the request meet these?
1822 */
1823static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
1824 struct snd_usb_substream *subs)
1825{
1826 struct audioformat *fp;
1827 int count = 0, needs_knot = 0;
1828 int err;
1829
1830 list_for_each_entry(fp, &subs->fmt_list, list) {
1831 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
1832 return 0;
1833 count += fp->nr_rates;
1834 if (fp->rates & SNDRV_PCM_RATE_KNOT)
1835 needs_knot = 1;
1836 }
1837 if (!needs_knot)
1838 return 0;
1839
1840 subs->rate_list.count = count;
1841 subs->rate_list.list = kmalloc(sizeof(int) * count, GFP_KERNEL);
1842 subs->rate_list.mask = 0;
1843 count = 0;
1844 list_for_each_entry(fp, &subs->fmt_list, list) {
1845 int i;
1846 for (i = 0; i < fp->nr_rates; i++)
1847 subs->rate_list.list[count++] = fp->rate_table[i];
1848 }
1849 err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1850 &subs->rate_list);
1851 if (err < 0)
1852 return err;
1853
1854 return 0;
1855}
1856
1857
1858/*
1859 * set up the runtime hardware information.
1860 */
1861
1862static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
1863{
1864 struct list_head *p;
1865 unsigned int pt, ptmin;
1866 int param_period_time_if_needed;
1867 int err;
1868
1869 runtime->hw.formats = subs->formats;
1870
1871 runtime->hw.rate_min = 0x7fffffff;
1872 runtime->hw.rate_max = 0;
1873 runtime->hw.channels_min = 256;
1874 runtime->hw.channels_max = 0;
1875 runtime->hw.rates = 0;
1876 ptmin = UINT_MAX;
1877 /* check min/max rates and channels */
1878 list_for_each(p, &subs->fmt_list) {
1879 struct audioformat *fp;
1880 fp = list_entry(p, struct audioformat, list);
1881 runtime->hw.rates |= fp->rates;
1882 if (runtime->hw.rate_min > fp->rate_min)
1883 runtime->hw.rate_min = fp->rate_min;
1884 if (runtime->hw.rate_max < fp->rate_max)
1885 runtime->hw.rate_max = fp->rate_max;
1886 if (runtime->hw.channels_min > fp->channels)
1887 runtime->hw.channels_min = fp->channels;
1888 if (runtime->hw.channels_max < fp->channels)
1889 runtime->hw.channels_max = fp->channels;
1890 if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
1891 /* FIXME: there might be more than one audio formats... */
1892 runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
1893 fp->frame_size;
1894 }
1895 pt = 125 * (1 << fp->datainterval);
1896 ptmin = min(ptmin, pt);
1897 }
1898
1899 param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
1900 if (snd_usb_get_speed(subs->dev) != USB_SPEED_HIGH)
1901 /* full speed devices have fixed data packet interval */
1902 ptmin = 1000;
1903 if (ptmin == 1000)
1904 /* if period time doesn't go below 1 ms, no rules needed */
1905 param_period_time_if_needed = -1;
1906 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1907 ptmin, UINT_MAX);
1908
1909 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1910 hw_rule_rate, subs,
1911 SNDRV_PCM_HW_PARAM_FORMAT,
1912 SNDRV_PCM_HW_PARAM_CHANNELS,
1913 param_period_time_if_needed,
1914 -1)) < 0)
1915 return err;
1916 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1917 hw_rule_channels, subs,
1918 SNDRV_PCM_HW_PARAM_FORMAT,
1919 SNDRV_PCM_HW_PARAM_RATE,
1920 param_period_time_if_needed,
1921 -1)) < 0)
1922 return err;
1923 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1924 hw_rule_format, subs,
1925 SNDRV_PCM_HW_PARAM_RATE,
1926 SNDRV_PCM_HW_PARAM_CHANNELS,
1927 param_period_time_if_needed,
1928 -1)) < 0)
1929 return err;
1930 if (param_period_time_if_needed >= 0) {
1931 err = snd_pcm_hw_rule_add(runtime, 0,
1932 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1933 hw_rule_period_time, subs,
1934 SNDRV_PCM_HW_PARAM_FORMAT,
1935 SNDRV_PCM_HW_PARAM_CHANNELS,
1936 SNDRV_PCM_HW_PARAM_RATE,
1937 -1);
1938 if (err < 0)
1939 return err;
1940 }
1941 if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
1942 return err;
1943 return 0;
1944}
1945
1946static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction)
1947{
1948 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1949 struct snd_pcm_runtime *runtime = substream->runtime;
1950 struct snd_usb_substream *subs = &as->substream[direction];
1951
1952 subs->interface = -1;
1953 subs->format = 0;
1954 runtime->hw = snd_usb_hardware;
1955 runtime->private_data = subs;
1956 subs->pcm_substream = substream;
1957 return setup_hw_info(runtime, subs);
1958}
1959
1960static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
1961{
1962 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1963 struct snd_usb_substream *subs = &as->substream[direction];
1964
1965 if (!as->chip->shutdown && subs->interface >= 0) {
1966 usb_set_interface(subs->dev, subs->interface, 0);
1967 subs->interface = -1;
1968 }
1969 subs->pcm_substream = NULL;
1970 return 0;
1971}
1972
1973static int snd_usb_playback_open(struct snd_pcm_substream *substream)
1974{
1975 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK);
1976}
1977
1978static int snd_usb_playback_close(struct snd_pcm_substream *substream)
1979{
1980 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
1981}
1982
1983static int snd_usb_capture_open(struct snd_pcm_substream *substream)
1984{
1985 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE);
1986}
1987
1988static int snd_usb_capture_close(struct snd_pcm_substream *substream)
1989{
1990 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
1991}
1992
1993static struct snd_pcm_ops snd_usb_playback_ops = {
1994 .open = snd_usb_playback_open,
1995 .close = snd_usb_playback_close,
1996 .ioctl = snd_pcm_lib_ioctl,
1997 .hw_params = snd_usb_hw_params,
1998 .hw_free = snd_usb_hw_free,
1999 .prepare = snd_usb_pcm_prepare,
2000 .trigger = snd_usb_pcm_playback_trigger,
2001 .pointer = snd_usb_pcm_pointer,
2002 .page = snd_pcm_lib_get_vmalloc_page,
2003 .mmap = snd_pcm_lib_mmap_vmalloc,
2004};
2005
2006static struct snd_pcm_ops snd_usb_capture_ops = {
2007 .open = snd_usb_capture_open,
2008 .close = snd_usb_capture_close,
2009 .ioctl = snd_pcm_lib_ioctl,
2010 .hw_params = snd_usb_hw_params,
2011 .hw_free = snd_usb_hw_free,
2012 .prepare = snd_usb_pcm_prepare,
2013 .trigger = snd_usb_pcm_capture_trigger,
2014 .pointer = snd_usb_pcm_pointer,
2015 .page = snd_pcm_lib_get_vmalloc_page,
2016 .mmap = snd_pcm_lib_mmap_vmalloc,
2017};
2018
2019
2020
2021/*
2022 * helper functions
2023 */
2024
2025/*
2026 * combine bytes and get an integer value
2027 */
2028unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
2029{
2030 switch (size) {
2031 case 1: return *bytes;
2032 case 2: return combine_word(bytes);
2033 case 3: return combine_triple(bytes);
2034 case 4: return combine_quad(bytes);
2035 default: return 0;
2036 }
2037}
2038
2039/*
2040 * parse descriptor buffer and return the pointer starting the given
2041 * descriptor type.
2042 */
2043void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype)
2044{
2045 u8 *p, *end, *next;
2046
2047 p = descstart;
2048 end = p + desclen;
2049 for (; p < end;) {
2050 if (p[0] < 2)
2051 return NULL;
2052 next = p + p[0];
2053 if (next > end)
2054 return NULL;
2055 if (p[1] == dtype && (!after || (void *)p > after)) {
2056 return p;
2057 }
2058 p = next;
2059 }
2060 return NULL;
2061}
2062
2063/*
2064 * find a class-specified interface descriptor with the given subtype.
2065 */
2066void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype)
2067{
2068 unsigned char *p = after;
2069
2070 while ((p = snd_usb_find_desc(buffer, buflen, p,
2071 USB_DT_CS_INTERFACE)) != NULL) {
2072 if (p[0] >= 3 && p[2] == dsubtype)
2073 return p;
2074 }
2075 return NULL;
2076}
2077
2078/*
2079 * Wrapper for usb_control_msg().
2080 * Allocates a temp buffer to prevent dmaing from/to the stack.
2081 */
2082int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
2083 __u8 requesttype, __u16 value, __u16 index, void *data,
2084 __u16 size, int timeout)
2085{
2086 int err;
2087 void *buf = NULL;
2088
2089 if (size > 0) {
2090 buf = kmemdup(data, size, GFP_KERNEL);
2091 if (!buf)
2092 return -ENOMEM;
2093 }
2094 err = usb_control_msg(dev, pipe, request, requesttype,
2095 value, index, buf, size, timeout);
2096 if (size > 0) {
2097 memcpy(data, buf, size);
2098 kfree(buf);
2099 }
2100 return err;
2101}
2102
2103
2104/*
2105 * entry point for linux usb interface
2106 */
2107
2108static int usb_audio_probe(struct usb_interface *intf,
2109 const struct usb_device_id *id);
2110static void usb_audio_disconnect(struct usb_interface *intf);
2111
2112#ifdef CONFIG_PM
2113static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message);
2114static int usb_audio_resume(struct usb_interface *intf);
2115#else
2116#define usb_audio_suspend NULL
2117#define usb_audio_resume NULL
2118#endif
2119
2120static struct usb_device_id usb_audio_ids [] = {
2121#include "usbquirks.h"
2122 { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
2123 .bInterfaceClass = USB_CLASS_AUDIO,
2124 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL },
2125 { } /* Terminating entry */
2126};
2127
2128MODULE_DEVICE_TABLE (usb, usb_audio_ids);
2129
2130static struct usb_driver usb_audio_driver = {
2131 .name = "snd-usb-audio",
2132 .probe = usb_audio_probe,
2133 .disconnect = usb_audio_disconnect,
2134 .suspend = usb_audio_suspend,
2135 .resume = usb_audio_resume,
2136 .id_table = usb_audio_ids,
2137};
2138
2139
2140#if defined(CONFIG_PROC_FS) && defined(CONFIG_SND_VERBOSE_PROCFS)
2141
2142/*
2143 * proc interface for list the supported pcm formats
2144 */
2145static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2146{
2147 struct list_head *p;
2148 static char *sync_types[4] = {
2149 "NONE", "ASYNC", "ADAPTIVE", "SYNC"
2150 };
2151
2152 list_for_each(p, &subs->fmt_list) {
2153 struct audioformat *fp;
2154 fp = list_entry(p, struct audioformat, list);
2155 snd_iprintf(buffer, " Interface %d\n", fp->iface);
2156 snd_iprintf(buffer, " Altset %d\n", fp->altsetting);
2157 snd_iprintf(buffer, " Format: %s\n",
2158 snd_pcm_format_name(fp->format));
2159 snd_iprintf(buffer, " Channels: %d\n", fp->channels);
2160 snd_iprintf(buffer, " Endpoint: %d %s (%s)\n",
2161 fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
2162 fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
2163 sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]);
2164 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
2165 snd_iprintf(buffer, " Rates: %d - %d (continuous)\n",
2166 fp->rate_min, fp->rate_max);
2167 } else {
2168 unsigned int i;
2169 snd_iprintf(buffer, " Rates: ");
2170 for (i = 0; i < fp->nr_rates; i++) {
2171 if (i > 0)
2172 snd_iprintf(buffer, ", ");
2173 snd_iprintf(buffer, "%d", fp->rate_table[i]);
2174 }
2175 snd_iprintf(buffer, "\n");
2176 }
2177 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
2178 snd_iprintf(buffer, " Data packet interval: %d us\n",
2179 125 * (1 << fp->datainterval));
2180 // snd_iprintf(buffer, " Max Packet Size = %d\n", fp->maxpacksize);
2181 // snd_iprintf(buffer, " EP Attribute = %#x\n", fp->attributes);
2182 }
2183}
2184
2185static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2186{
2187 if (subs->running) {
2188 unsigned int i;
2189 snd_iprintf(buffer, " Status: Running\n");
2190 snd_iprintf(buffer, " Interface = %d\n", subs->interface);
2191 snd_iprintf(buffer, " Altset = %d\n", subs->format);
2192 snd_iprintf(buffer, " URBs = %d [ ", subs->nurbs);
2193 for (i = 0; i < subs->nurbs; i++)
2194 snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
2195 snd_iprintf(buffer, "]\n");
2196 snd_iprintf(buffer, " Packet Size = %d\n", subs->curpacksize);
2197 snd_iprintf(buffer, " Momentary freq = %u Hz (%#x.%04x)\n",
2198 snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
2199 ? get_full_speed_hz(subs->freqm)
2200 : get_high_speed_hz(subs->freqm),
2201 subs->freqm >> 16, subs->freqm & 0xffff);
2202 } else {
2203 snd_iprintf(buffer, " Status: Stop\n");
2204 }
2205}
2206
2207static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
2208{
2209 struct snd_usb_stream *stream = entry->private_data;
2210
2211 snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
2212
2213 if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
2214 snd_iprintf(buffer, "\nPlayback:\n");
2215 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2216 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2217 }
2218 if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
2219 snd_iprintf(buffer, "\nCapture:\n");
2220 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2221 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2222 }
2223}
2224
2225static void proc_pcm_format_add(struct snd_usb_stream *stream)
2226{
2227 struct snd_info_entry *entry;
2228 char name[32];
2229 struct snd_card *card = stream->chip->card;
2230
2231 sprintf(name, "stream%d", stream->pcm_index);
2232 if (!snd_card_proc_new(card, name, &entry))
2233 snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
2234}
2235
2236#else
2237
2238static inline void proc_pcm_format_add(struct snd_usb_stream *stream)
2239{
2240}
2241
2242#endif
2243
2244/*
2245 * initialize the substream instance.
2246 */
2247
2248static void init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp)
2249{
2250 struct snd_usb_substream *subs = &as->substream[stream];
2251
2252 INIT_LIST_HEAD(&subs->fmt_list);
2253 spin_lock_init(&subs->lock);
2254
2255 subs->stream = as;
2256 subs->direction = stream;
2257 subs->dev = as->chip->dev;
2258 subs->txfr_quirk = as->chip->txfr_quirk;
2259 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) {
2260 subs->ops = audio_urb_ops[stream];
2261 } else {
2262 subs->ops = audio_urb_ops_high_speed[stream];
2263 switch (as->chip->usb_id) {
2264 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
2265 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
2266 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
2267 subs->ops.retire_sync = retire_playback_sync_urb_hs_emu;
2268 break;
2269 }
2270 }
2271 snd_pcm_set_ops(as->pcm, stream,
2272 stream == SNDRV_PCM_STREAM_PLAYBACK ?
2273 &snd_usb_playback_ops : &snd_usb_capture_ops);
2274
2275 list_add_tail(&fp->list, &subs->fmt_list);
2276 subs->formats |= 1ULL << fp->format;
2277 subs->endpoint = fp->endpoint;
2278 subs->num_formats++;
2279 subs->fmt_type = fp->fmt_type;
2280}
2281
2282
2283/*
2284 * free a substream
2285 */
2286static void free_substream(struct snd_usb_substream *subs)
2287{
2288 struct list_head *p, *n;
2289
2290 if (!subs->num_formats)
2291 return; /* not initialized */
2292 list_for_each_safe(p, n, &subs->fmt_list) {
2293 struct audioformat *fp = list_entry(p, struct audioformat, list);
2294 kfree(fp->rate_table);
2295 kfree(fp);
2296 }
2297 kfree(subs->rate_list.list);
2298}
2299
2300
2301/*
2302 * free a usb stream instance
2303 */
2304static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
2305{
2306 free_substream(&stream->substream[0]);
2307 free_substream(&stream->substream[1]);
2308 list_del(&stream->list);
2309 kfree(stream);
2310}
2311
2312static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
2313{
2314 struct snd_usb_stream *stream = pcm->private_data;
2315 if (stream) {
2316 stream->pcm = NULL;
2317 snd_usb_audio_stream_free(stream);
2318 }
2319}
2320
2321
2322/*
2323 * add this endpoint to the chip instance.
2324 * if a stream with the same endpoint already exists, append to it.
2325 * if not, create a new pcm stream.
2326 */
2327static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp)
2328{
2329 struct list_head *p;
2330 struct snd_usb_stream *as;
2331 struct snd_usb_substream *subs;
2332 struct snd_pcm *pcm;
2333 int err;
2334
2335 list_for_each(p, &chip->pcm_list) {
2336 as = list_entry(p, struct snd_usb_stream, list);
2337 if (as->fmt_type != fp->fmt_type)
2338 continue;
2339 subs = &as->substream[stream];
2340 if (!subs->endpoint)
2341 continue;
2342 if (subs->endpoint == fp->endpoint) {
2343 list_add_tail(&fp->list, &subs->fmt_list);
2344 subs->num_formats++;
2345 subs->formats |= 1ULL << fp->format;
2346 return 0;
2347 }
2348 }
2349 /* look for an empty stream */
2350 list_for_each(p, &chip->pcm_list) {
2351 as = list_entry(p, struct snd_usb_stream, list);
2352 if (as->fmt_type != fp->fmt_type)
2353 continue;
2354 subs = &as->substream[stream];
2355 if (subs->endpoint)
2356 continue;
2357 err = snd_pcm_new_stream(as->pcm, stream, 1);
2358 if (err < 0)
2359 return err;
2360 init_substream(as, stream, fp);
2361 return 0;
2362 }
2363
2364 /* create a new pcm */
2365 as = kzalloc(sizeof(*as), GFP_KERNEL);
2366 if (!as)
2367 return -ENOMEM;
2368 as->pcm_index = chip->pcm_devs;
2369 as->chip = chip;
2370 as->fmt_type = fp->fmt_type;
2371 err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
2372 stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
2373 stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
2374 &pcm);
2375 if (err < 0) {
2376 kfree(as);
2377 return err;
2378 }
2379 as->pcm = pcm;
2380 pcm->private_data = as;
2381 pcm->private_free = snd_usb_audio_pcm_free;
2382 pcm->info_flags = 0;
2383 if (chip->pcm_devs > 0)
2384 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
2385 else
2386 strcpy(pcm->name, "USB Audio");
2387
2388 init_substream(as, stream, fp);
2389
2390 list_add(&as->list, &chip->pcm_list);
2391 chip->pcm_devs++;
2392
2393 proc_pcm_format_add(as);
2394
2395 return 0;
2396}
2397
2398
2399/*
2400 * check if the device uses big-endian samples
2401 */
2402static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
2403{
2404 switch (chip->usb_id) {
2405 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
2406 if (fp->endpoint & USB_DIR_IN)
2407 return 1;
2408 break;
2409 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2410 if (device_setup[chip->index] == 0x00 ||
2411 fp->altsetting==1 || fp->altsetting==2 || fp->altsetting==3)
2412 return 1;
2413 }
2414 return 0;
2415}
2416
2417/*
2418 * parse the audio format type I descriptor
2419 * and returns the corresponding pcm format
2420 *
2421 * @dev: usb device
2422 * @fp: audioformat record
2423 * @format: the format tag (wFormatTag)
2424 * @fmt: the format type descriptor
2425 */
2426static int parse_audio_format_i_type(struct snd_usb_audio *chip,
2427 struct audioformat *fp,
2428 int format, void *_fmt,
2429 int protocol)
2430{
2431 int pcm_format, i;
2432 int sample_width, sample_bytes;
2433
2434 switch (protocol) {
2435 case UAC_VERSION_1: {
2436 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
2437 sample_width = fmt->bBitResolution;
2438 sample_bytes = fmt->bSubframeSize;
2439 break;
2440 }
2441
2442 case UAC_VERSION_2: {
2443 struct uac_format_type_i_ext_descriptor *fmt = _fmt;
2444 sample_width = fmt->bBitResolution;
2445 sample_bytes = fmt->bSubslotSize;
2446
2447 /*
2448 * FIXME
2449 * USB audio class v2 devices specify a bitmap of possible
2450 * audio formats rather than one fix value. For now, we just
2451 * pick one of them and report that as the only possible
2452 * value for this setting.
2453 * The bit allocation map is in fact compatible to the
2454 * wFormatTag of the v1 AS streaming descriptors, which is why
2455 * we can simply map the matrix.
2456 */
2457
2458 for (i = 0; i < 5; i++)
2459 if (format & (1UL << i)) {
2460 format = i + 1;
2461 break;
2462 }
2463
2464 break;
2465 }
2466
2467 default:
2468 return -EINVAL;
2469 }
2470
2471 /* FIXME: correct endianess and sign? */
2472 pcm_format = -1;
2473
2474 switch (format) {
2475 case UAC_FORMAT_TYPE_I_UNDEFINED: /* some devices don't define this correctly... */
2476 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
2477 chip->dev->devnum, fp->iface, fp->altsetting);
2478 /* fall-through */
2479 case UAC_FORMAT_TYPE_I_PCM:
2480 if (sample_width > sample_bytes * 8) {
2481 snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
2482 chip->dev->devnum, fp->iface, fp->altsetting,
2483 sample_width, sample_bytes);
2484 }
2485 /* check the format byte size */
2486 switch (sample_bytes) {
2487 case 1:
2488 pcm_format = SNDRV_PCM_FORMAT_S8;
2489 break;
2490 case 2:
2491 if (is_big_endian_format(chip, fp))
2492 pcm_format = SNDRV_PCM_FORMAT_S16_BE; /* grrr, big endian!! */
2493 else
2494 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2495 break;
2496 case 3:
2497 if (is_big_endian_format(chip, fp))
2498 pcm_format = SNDRV_PCM_FORMAT_S24_3BE; /* grrr, big endian!! */
2499 else
2500 pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
2501 break;
2502 case 4:
2503 pcm_format = SNDRV_PCM_FORMAT_S32_LE;
2504 break;
2505 default:
2506 snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
2507 chip->dev->devnum, fp->iface, fp->altsetting,
2508 sample_width, sample_bytes);
2509 break;
2510 }
2511 break;
2512 case UAC_FORMAT_TYPE_I_PCM8:
2513 pcm_format = SNDRV_PCM_FORMAT_U8;
2514
2515 /* Dallas DS4201 workaround: it advertises U8 format, but really
2516 supports S8. */
2517 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2518 pcm_format = SNDRV_PCM_FORMAT_S8;
2519 break;
2520 case UAC_FORMAT_TYPE_I_IEEE_FLOAT:
2521 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
2522 break;
2523 case UAC_FORMAT_TYPE_I_ALAW:
2524 pcm_format = SNDRV_PCM_FORMAT_A_LAW;
2525 break;
2526 case UAC_FORMAT_TYPE_I_MULAW:
2527 pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
2528 break;
2529 default:
2530 snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n",
2531 chip->dev->devnum, fp->iface, fp->altsetting, format);
2532 break;
2533 }
2534 return pcm_format;
2535}
2536
2537
2538/*
2539 * parse the format descriptor and stores the possible sample rates
2540 * on the audioformat table (audio class v1).
2541 *
2542 * @dev: usb device
2543 * @fp: audioformat record
2544 * @fmt: the format descriptor
2545 * @offset: the start offset of descriptor pointing the rate type
2546 * (7 for type I and II, 8 for type II)
2547 */
2548static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp,
2549 unsigned char *fmt, int offset)
2550{
2551 int nr_rates = fmt[offset];
2552
2553 if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
2554 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
2555 chip->dev->devnum, fp->iface, fp->altsetting);
2556 return -1;
2557 }
2558
2559 if (nr_rates) {
2560 /*
2561 * build the rate table and bitmap flags
2562 */
2563 int r, idx;
2564
2565 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
2566 if (fp->rate_table == NULL) {
2567 snd_printk(KERN_ERR "cannot malloc\n");
2568 return -1;
2569 }
2570
2571 fp->nr_rates = 0;
2572 fp->rate_min = fp->rate_max = 0;
2573 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
2574 unsigned int rate = combine_triple(&fmt[idx]);
2575 if (!rate)
2576 continue;
2577 /* C-Media CM6501 mislabels its 96 kHz altsetting */
2578 if (rate == 48000 && nr_rates == 1 &&
2579 (chip->usb_id == USB_ID(0x0d8c, 0x0201) ||
2580 chip->usb_id == USB_ID(0x0d8c, 0x0102)) &&
2581 fp->altsetting == 5 && fp->maxpacksize == 392)
2582 rate = 96000;
2583 /* Creative VF0470 Live Cam reports 16 kHz instead of 8kHz */
2584 if (rate == 16000 && chip->usb_id == USB_ID(0x041e, 0x4068))
2585 rate = 8000;
2586 fp->rate_table[fp->nr_rates] = rate;
2587 if (!fp->rate_min || rate < fp->rate_min)
2588 fp->rate_min = rate;
2589 if (!fp->rate_max || rate > fp->rate_max)
2590 fp->rate_max = rate;
2591 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
2592 fp->nr_rates++;
2593 }
2594 if (!fp->nr_rates) {
2595 hwc_debug("All rates were zero. Skipping format!\n");
2596 return -1;
2597 }
2598 } else {
2599 /* continuous rates */
2600 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
2601 fp->rate_min = combine_triple(&fmt[offset + 1]);
2602 fp->rate_max = combine_triple(&fmt[offset + 4]);
2603 }
2604 return 0;
2605}
2606
2607/*
2608 * parse the format descriptor and stores the possible sample rates
2609 * on the audioformat table (audio class v2).
2610 */
2611static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
2612 struct audioformat *fp,
2613 struct usb_host_interface *iface)
2614{
2615 struct usb_device *dev = chip->dev;
2616 unsigned char tmp[2], *data;
2617 int i, nr_rates, data_size, ret = 0;
2618
2619 /* get the number of sample rates first by only fetching 2 bytes */
2620 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
2621 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
2622 0x0100, chip->clock_id << 8, tmp, sizeof(tmp), 1000);
2623
2624 if (ret < 0) {
2625 snd_printk(KERN_ERR "unable to retrieve number of sample rates\n");
2626 goto err;
2627 }
2628
2629 nr_rates = (tmp[1] << 8) | tmp[0];
2630 data_size = 2 + 12 * nr_rates;
2631 data = kzalloc(data_size, GFP_KERNEL);
2632 if (!data) {
2633 ret = -ENOMEM;
2634 goto err;
2635 }
2636
2637 /* now get the full information */
2638 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
2639 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
2640 0x0100, chip->clock_id << 8, data, data_size, 1000);
2641
2642 if (ret < 0) {
2643 snd_printk(KERN_ERR "unable to retrieve sample rate range\n");
2644 ret = -EINVAL;
2645 goto err_free;
2646 }
2647
2648 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
2649 if (!fp->rate_table) {
2650 ret = -ENOMEM;
2651 goto err_free;
2652 }
2653
2654 fp->nr_rates = 0;
2655 fp->rate_min = fp->rate_max = 0;
2656
2657 for (i = 0; i < nr_rates; i++) {
2658 int rate = combine_quad(&data[2 + 12 * i]);
2659
2660 fp->rate_table[fp->nr_rates] = rate;
2661 if (!fp->rate_min || rate < fp->rate_min)
2662 fp->rate_min = rate;
2663 if (!fp->rate_max || rate > fp->rate_max)
2664 fp->rate_max = rate;
2665 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
2666 fp->nr_rates++;
2667 }
2668
2669err_free:
2670 kfree(data);
2671err:
2672 return ret;
2673}
2674
2675/*
2676 * parse the format type I and III descriptors
2677 */
2678static int parse_audio_format_i(struct snd_usb_audio *chip,
2679 struct audioformat *fp,
2680 int format, void *_fmt,
2681 struct usb_host_interface *iface)
2682{
2683 struct usb_interface_descriptor *altsd = get_iface_desc(iface);
2684 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
2685 int protocol = altsd->bInterfaceProtocol;
2686 int pcm_format, ret;
2687
2688 if (fmt->bFormatType == UAC_FORMAT_TYPE_III) {
2689 /* FIXME: the format type is really IECxxx
2690 * but we give normal PCM format to get the existing
2691 * apps working...
2692 */
2693 switch (chip->usb_id) {
2694
2695 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2696 if (device_setup[chip->index] == 0x00 &&
2697 fp->altsetting == 6)
2698 pcm_format = SNDRV_PCM_FORMAT_S16_BE;
2699 else
2700 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2701 break;
2702 default:
2703 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2704 }
2705 } else {
2706 pcm_format = parse_audio_format_i_type(chip, fp, format, fmt, protocol);
2707 if (pcm_format < 0)
2708 return -1;
2709 }
2710
2711 fp->format = pcm_format;
2712
2713 /* gather possible sample rates */
2714 /* audio class v1 reports possible sample rates as part of the
2715 * proprietary class specific descriptor.
2716 * audio class v2 uses class specific EP0 range requests for that.
2717 */
2718 switch (protocol) {
2719 case UAC_VERSION_1:
2720 fp->channels = fmt->bNrChannels;
2721 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 7);
2722 break;
2723 case UAC_VERSION_2:
2724 /* fp->channels is already set in this case */
2725 ret = parse_audio_format_rates_v2(chip, fp, iface);
2726 break;
2727 }
2728
2729 if (fp->channels < 1) {
2730 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
2731 chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
2732 return -1;
2733 }
2734
2735 return ret;
2736}
2737
2738/*
2739 * parse the format type II descriptor
2740 */
2741static int parse_audio_format_ii(struct snd_usb_audio *chip,
2742 struct audioformat *fp,
2743 int format, void *_fmt,
2744 struct usb_host_interface *iface)
2745{
2746 int brate, framesize, ret;
2747 struct usb_interface_descriptor *altsd = get_iface_desc(iface);
2748 int protocol = altsd->bInterfaceProtocol;
2749
2750 switch (format) {
2751 case UAC_FORMAT_TYPE_II_AC3:
2752 /* FIXME: there is no AC3 format defined yet */
2753 // fp->format = SNDRV_PCM_FORMAT_AC3;
2754 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
2755 break;
2756 case UAC_FORMAT_TYPE_II_MPEG:
2757 fp->format = SNDRV_PCM_FORMAT_MPEG;
2758 break;
2759 default:
2760 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected. processed as MPEG.\n",
2761 chip->dev->devnum, fp->iface, fp->altsetting, format);
2762 fp->format = SNDRV_PCM_FORMAT_MPEG;
2763 break;
2764 }
2765
2766 fp->channels = 1;
2767
2768 switch (protocol) {
2769 case UAC_VERSION_1: {
2770 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
2771 brate = le16_to_cpu(fmt->wMaxBitRate);
2772 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
2773 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
2774 fp->frame_size = framesize;
2775 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
2776 break;
2777 }
2778 case UAC_VERSION_2: {
2779 struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
2780 brate = le16_to_cpu(fmt->wMaxBitRate);
2781 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
2782 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
2783 fp->frame_size = framesize;
2784 ret = parse_audio_format_rates_v2(chip, fp, iface);
2785 break;
2786 }
2787 }
2788
2789 return ret;
2790}
2791
2792static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
2793 int format, unsigned char *fmt, int stream,
2794 struct usb_host_interface *iface)
2795{
2796 int err;
2797
2798 switch (fmt[3]) {
2799 case UAC_FORMAT_TYPE_I:
2800 case UAC_FORMAT_TYPE_III:
2801 err = parse_audio_format_i(chip, fp, format, fmt, iface);
2802 break;
2803 case UAC_FORMAT_TYPE_II:
2804 err = parse_audio_format_ii(chip, fp, format, fmt, iface);
2805 break;
2806 default:
2807 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
2808 chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
2809 return -1;
2810 }
2811 fp->fmt_type = fmt[3];
2812 if (err < 0)
2813 return err;
2814#if 1
2815 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
2816 /* extigy apparently supports sample rates other than 48k
2817 * but not in ordinary way. so we enable only 48k atm.
2818 */
2819 if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
2820 chip->usb_id == USB_ID(0x041e, 0x3020) ||
2821 chip->usb_id == USB_ID(0x041e, 0x3061)) {
2822 if (fmt[3] == UAC_FORMAT_TYPE_I &&
2823 fp->rates != SNDRV_PCM_RATE_48000 &&
2824 fp->rates != SNDRV_PCM_RATE_96000)
2825 return -1;
2826 }
2827#endif
2828 return 0;
2829}
2830
2831static unsigned char parse_datainterval(struct snd_usb_audio *chip,
2832 struct usb_host_interface *alts)
2833{
2834 if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH &&
2835 get_endpoint(alts, 0)->bInterval >= 1 &&
2836 get_endpoint(alts, 0)->bInterval <= 4)
2837 return get_endpoint(alts, 0)->bInterval - 1;
2838 else
2839 return 0;
2840}
2841
2842static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
2843 int iface, int altno);
2844static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
2845{
2846 struct usb_device *dev;
2847 struct usb_interface *iface;
2848 struct usb_host_interface *alts;
2849 struct usb_interface_descriptor *altsd;
2850 int i, altno, err, stream;
2851 int format = 0, num_channels = 0;
2852 struct audioformat *fp = NULL;
2853 unsigned char *fmt, *csep;
2854 int num, protocol;
2855
2856 dev = chip->dev;
2857
2858 /* parse the interface's altsettings */
2859 iface = usb_ifnum_to_if(dev, iface_no);
2860
2861 num = iface->num_altsetting;
2862
2863 /*
2864 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
2865 * one misses syncpipe, and does not produce any sound.
2866 */
2867 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2868 num = 4;
2869
2870 for (i = 0; i < num; i++) {
2871 alts = &iface->altsetting[i];
2872 altsd = get_iface_desc(alts);
2873 protocol = altsd->bInterfaceProtocol;
2874 /* skip invalid one */
2875 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2876 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2877 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
2878 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
2879 altsd->bNumEndpoints < 1 ||
2880 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
2881 continue;
2882 /* must be isochronous */
2883 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
2884 USB_ENDPOINT_XFER_ISOC)
2885 continue;
2886 /* check direction */
2887 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
2888 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2889 altno = altsd->bAlternateSetting;
2890
2891 /* audiophile usb: skip altsets incompatible with device_setup
2892 */
2893 if (chip->usb_id == USB_ID(0x0763, 0x2003) &&
2894 audiophile_skip_setting_quirk(chip, iface_no, altno))
2895 continue;
2896
2897 /* get audio formats */
2898 switch (protocol) {
2899 case UAC_VERSION_1: {
2900 struct uac_as_header_descriptor_v1 *as =
2901 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
2902
2903 if (!as) {
2904 snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
2905 dev->devnum, iface_no, altno);
2906 continue;
2907 }
2908
2909 if (as->bLength < sizeof(*as)) {
2910 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
2911 dev->devnum, iface_no, altno);
2912 continue;
2913 }
2914
2915 format = le16_to_cpu(as->wFormatTag); /* remember the format value */
2916 break;
2917 }
2918
2919 case UAC_VERSION_2: {
2920 struct uac_as_header_descriptor_v2 *as =
2921 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
2922
2923 if (!as) {
2924 snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
2925 dev->devnum, iface_no, altno);
2926 continue;
2927 }
2928
2929 if (as->bLength < sizeof(*as)) {
2930 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
2931 dev->devnum, iface_no, altno);
2932 continue;
2933 }
2934
2935 num_channels = as->bNrChannels;
2936 format = le32_to_cpu(as->bmFormats);
2937
2938 break;
2939 }
2940
2941 default:
2942 snd_printk(KERN_ERR "%d:%u:%d : unknown interface protocol %04x\n",
2943 dev->devnum, iface_no, altno, protocol);
2944 continue;
2945 }
2946
2947 /* get format type */
2948 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
2949 if (!fmt) {
2950 snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n",
2951 dev->devnum, iface_no, altno);
2952 continue;
2953 }
2954 if (((protocol == UAC_VERSION_1) && (fmt[0] < 8)) ||
2955 ((protocol == UAC_VERSION_2) && (fmt[0] != 6))) {
2956 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
2957 dev->devnum, iface_no, altno);
2958 continue;
2959 }
2960
2961 /*
2962 * Blue Microphones workaround: The last altsetting is identical
2963 * with the previous one, except for a larger packet size, but
2964 * is actually a mislabeled two-channel setting; ignore it.
2965 */
2966 if (fmt[4] == 1 && fmt[5] == 2 && altno == 2 && num == 3 &&
2967 fp && fp->altsetting == 1 && fp->channels == 1 &&
2968 fp->format == SNDRV_PCM_FORMAT_S16_LE &&
2969 protocol == UAC_VERSION_1 &&
2970 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
2971 fp->maxpacksize * 2)
2972 continue;
2973
2974 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
2975 /* Creamware Noah has this descriptor after the 2nd endpoint */
2976 if (!csep && altsd->bNumEndpoints >= 2)
2977 csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
2978 if (!csep || csep[0] < 7 || csep[2] != UAC_EP_GENERAL) {
2979 snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
2980 " class specific endpoint descriptor\n",
2981 dev->devnum, iface_no, altno);
2982 csep = NULL;
2983 }
2984
2985 fp = kzalloc(sizeof(*fp), GFP_KERNEL);
2986 if (! fp) {
2987 snd_printk(KERN_ERR "cannot malloc\n");
2988 return -ENOMEM;
2989 }
2990
2991 fp->iface = iface_no;
2992 fp->altsetting = altno;
2993 fp->altset_idx = i;
2994 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2995 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2996 fp->datainterval = parse_datainterval(chip, alts);
2997 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2998 /* num_channels is only set for v2 interfaces */
2999 fp->channels = num_channels;
3000 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
3001 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
3002 * (fp->maxpacksize & 0x7ff);
3003 fp->attributes = csep ? csep[3] : 0;
3004
3005 /* some quirks for attributes here */
3006
3007 switch (chip->usb_id) {
3008 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
3009 /* Optoplay sets the sample rate attribute although
3010 * it seems not supporting it in fact.
3011 */
3012 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
3013 break;
3014 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
3015 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
3016 /* doesn't set the sample rate attribute, but supports it */
3017 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
3018 break;
3019 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
3020 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
3021 an older model 77d:223) */
3022 /*
3023 * plantronics headset and Griffin iMic have set adaptive-in
3024 * although it's really not...
3025 */
3026 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
3027 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3028 fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
3029 else
3030 fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
3031 break;
3032 }
3033
3034 /* ok, let's parse further... */
3035 if (parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) {
3036 kfree(fp->rate_table);
3037 kfree(fp);
3038 continue;
3039 }
3040
3041 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint %#x\n", dev->devnum, iface_no, altno, fp->endpoint);
3042 err = add_audio_endpoint(chip, stream, fp);
3043 if (err < 0) {
3044 kfree(fp->rate_table);
3045 kfree(fp);
3046 return err;
3047 }
3048 /* try to set the interface... */
3049 usb_set_interface(chip->dev, iface_no, altno);
3050 init_usb_pitch(chip->dev, iface_no, alts, fp);
3051 init_usb_sample_rate(chip->dev, iface_no, alts, fp, fp->rate_max);
3052 }
3053 return 0;
3054}
3055
3056
3057/*
3058 * disconnect streams
3059 * called from snd_usb_audio_disconnect()
3060 */
3061static void snd_usb_stream_disconnect(struct list_head *head)
3062{
3063 int idx;
3064 struct snd_usb_stream *as;
3065 struct snd_usb_substream *subs;
3066
3067 as = list_entry(head, struct snd_usb_stream, list);
3068 for (idx = 0; idx < 2; idx++) {
3069 subs = &as->substream[idx];
3070 if (!subs->num_formats)
3071 return;
3072 release_substream_urbs(subs, 1);
3073 subs->interface = -1;
3074 }
3075}
3076
3077static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface)
3078{
3079 struct usb_device *dev = chip->dev;
3080 struct usb_host_interface *alts;
3081 struct usb_interface_descriptor *altsd;
3082 struct usb_interface *iface = usb_ifnum_to_if(dev, interface);
3083
3084 if (!iface) {
3085 snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
3086 dev->devnum, ctrlif, interface);
3087 return -EINVAL;
3088 }
3089
3090 if (usb_interface_claimed(iface)) {
3091 snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",
3092 dev->devnum, ctrlif, interface);
3093 return -EINVAL;
3094 }
3095
3096 alts = &iface->altsetting[0];
3097 altsd = get_iface_desc(alts);
3098 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
3099 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
3100 altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) {
3101 int err = snd_usbmidi_create(chip->card, iface,
3102 &chip->midi_list, NULL);
3103 if (err < 0) {
3104 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",
3105 dev->devnum, ctrlif, interface);
3106 return -EINVAL;
3107 }
3108 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
3109
3110 return 0;
3111 }
3112
3113 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
3114 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
3115 altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {
3116 snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",
3117 dev->devnum, ctrlif, interface, altsd->bInterfaceClass);
3118 /* skip non-supported classes */
3119 return -EINVAL;
3120 }
3121
3122 if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
3123 snd_printk(KERN_ERR "low speed audio streaming not supported\n");
3124 return -EINVAL;
3125 }
3126
3127 if (! parse_audio_endpoints(chip, interface)) {
3128 usb_set_interface(dev, interface, 0); /* reset the current interface */
3129 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
3130 return -EINVAL;
3131 }
3132
3133 return 0;
3134}
3135
3136/*
3137 * parse audio control descriptor and create pcm/midi streams
3138 */
3139static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
3140{
3141 struct usb_device *dev = chip->dev;
3142 struct usb_host_interface *host_iface;
3143 struct usb_interface_descriptor *altsd;
3144 void *control_header;
3145 int i, protocol;
3146
3147 /* find audiocontrol interface */
3148 host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
3149 control_header = snd_usb_find_csint_desc(host_iface->extra,
3150 host_iface->extralen,
3151 NULL, UAC_HEADER);
3152 altsd = get_iface_desc(host_iface);
3153 protocol = altsd->bInterfaceProtocol;
3154
3155 if (!control_header) {
3156 snd_printk(KERN_ERR "cannot find UAC_HEADER\n");
3157 return -EINVAL;
3158 }
3159
3160 switch (protocol) {
3161 case UAC_VERSION_1: {
3162 struct uac_ac_header_descriptor_v1 *h1 = control_header;
3163
3164 if (!h1->bInCollection) {
3165 snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
3166 return -EINVAL;
3167 }
3168
3169 if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
3170 snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");
3171 return -EINVAL;
3172 }
3173
3174 for (i = 0; i < h1->bInCollection; i++)
3175 snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]);
3176
3177 break;
3178 }
3179
3180 case UAC_VERSION_2: {
3181 struct uac_clock_source_descriptor *cs;
3182 struct usb_interface_assoc_descriptor *assoc =
3183 usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
3184
3185 if (!assoc) {
3186 snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");
3187 return -EINVAL;
3188 }
3189
3190 /* FIXME: for now, we expect there is at least one clock source
3191 * descriptor and we always take the first one.
3192 * We should properly support devices with multiple clock sources,
3193 * clock selectors and sample rate conversion units. */
3194
3195 cs = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen,
3196 NULL, UAC_CLOCK_SOURCE);
3197
3198 if (!cs) {
3199 snd_printk(KERN_ERR "CLOCK_SOURCE descriptor not found\n");
3200 return -EINVAL;
3201 }
3202
3203 chip->clock_id = cs->bClockID;
3204
3205 for (i = 0; i < assoc->bInterfaceCount; i++) {
3206 int intf = assoc->bFirstInterface + i;
3207
3208 if (intf != ctrlif)
3209 snd_usb_create_stream(chip, ctrlif, intf);
3210 }
3211
3212 break;
3213 }
3214
3215 default:
3216 snd_printk(KERN_ERR "unknown protocol version 0x%02x\n", protocol);
3217 return -EINVAL;
3218 }
3219
3220 return 0;
3221}
3222
3223/*
3224 * create a stream for an endpoint/altsetting without proper descriptors
3225 */
3226static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
3227 struct usb_interface *iface,
3228 const struct snd_usb_audio_quirk *quirk)
3229{
3230 struct audioformat *fp;
3231 struct usb_host_interface *alts;
3232 int stream, err;
3233 unsigned *rate_table = NULL;
3234
3235 fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
3236 if (! fp) {
3237 snd_printk(KERN_ERR "cannot memdup\n");
3238 return -ENOMEM;
3239 }
3240 if (fp->nr_rates > 0) {
3241 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
3242 if (!rate_table) {
3243 kfree(fp);
3244 return -ENOMEM;
3245 }
3246 memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates);
3247 fp->rate_table = rate_table;
3248 }
3249
3250 stream = (fp->endpoint & USB_DIR_IN)
3251 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3252 err = add_audio_endpoint(chip, stream, fp);
3253 if (err < 0) {
3254 kfree(fp);
3255 kfree(rate_table);
3256 return err;
3257 }
3258 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
3259 fp->altset_idx >= iface->num_altsetting) {
3260 kfree(fp);
3261 kfree(rate_table);
3262 return -EINVAL;
3263 }
3264 alts = &iface->altsetting[fp->altset_idx];
3265 fp->datainterval = parse_datainterval(chip, alts);
3266 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3267 usb_set_interface(chip->dev, fp->iface, 0);
3268 init_usb_pitch(chip->dev, fp->iface, alts, fp);
3269 init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max);
3270 return 0;
3271}
3272
3273/*
3274 * create a stream for an interface with proper descriptors
3275 */
3276static int create_standard_audio_quirk(struct snd_usb_audio *chip,
3277 struct usb_interface *iface,
3278 const struct snd_usb_audio_quirk *quirk)
3279{
3280 struct usb_host_interface *alts;
3281 struct usb_interface_descriptor *altsd;
3282 int err;
3283
3284 alts = &iface->altsetting[0];
3285 altsd = get_iface_desc(alts);
3286 err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
3287 if (err < 0) {
3288 snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
3289 altsd->bInterfaceNumber, err);
3290 return err;
3291 }
3292 /* reset the current interface */
3293 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
3294 return 0;
3295}
3296
3297/*
3298 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
3299 * The only way to detect the sample rate is by looking at wMaxPacketSize.
3300 */
3301static int create_uaxx_quirk(struct snd_usb_audio *chip,
3302 struct usb_interface *iface,
3303 const struct snd_usb_audio_quirk *quirk)
3304{
3305 static const struct audioformat ua_format = {
3306 .format = SNDRV_PCM_FORMAT_S24_3LE,
3307 .channels = 2,
3308 .fmt_type = UAC_FORMAT_TYPE_I,
3309 .altsetting = 1,
3310 .altset_idx = 1,
3311 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3312 };
3313 struct usb_host_interface *alts;
3314 struct usb_interface_descriptor *altsd;
3315 struct audioformat *fp;
3316 int stream, err;
3317
3318 /* both PCM and MIDI interfaces have 2 or more altsettings */
3319 if (iface->num_altsetting < 2)
3320 return -ENXIO;
3321 alts = &iface->altsetting[1];
3322 altsd = get_iface_desc(alts);
3323
3324 if (altsd->bNumEndpoints == 2) {
3325 static const struct snd_usb_midi_endpoint_info ua700_ep = {
3326 .out_cables = 0x0003,
3327 .in_cables = 0x0003
3328 };
3329 static const struct snd_usb_audio_quirk ua700_quirk = {
3330 .type = QUIRK_MIDI_FIXED_ENDPOINT,
3331 .data = &ua700_ep
3332 };
3333 static const struct snd_usb_midi_endpoint_info uaxx_ep = {
3334 .out_cables = 0x0001,
3335 .in_cables = 0x0001
3336 };
3337 static const struct snd_usb_audio_quirk uaxx_quirk = {
3338 .type = QUIRK_MIDI_FIXED_ENDPOINT,
3339 .data = &uaxx_ep
3340 };
3341 const struct snd_usb_audio_quirk *quirk =
3342 chip->usb_id == USB_ID(0x0582, 0x002b)
3343 ? &ua700_quirk : &uaxx_quirk;
3344 return snd_usbmidi_create(chip->card, iface,
3345 &chip->midi_list, quirk);
3346 }
3347
3348 if (altsd->bNumEndpoints != 1)
3349 return -ENXIO;
3350
3351 fp = kmalloc(sizeof(*fp), GFP_KERNEL);
3352 if (!fp)
3353 return -ENOMEM;
3354 memcpy(fp, &ua_format, sizeof(*fp));
3355
3356 fp->iface = altsd->bInterfaceNumber;
3357 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3358 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3359 fp->datainterval = 0;
3360 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3361
3362 switch (fp->maxpacksize) {
3363 case 0x120:
3364 fp->rate_max = fp->rate_min = 44100;
3365 break;
3366 case 0x138:
3367 case 0x140:
3368 fp->rate_max = fp->rate_min = 48000;
3369 break;
3370 case 0x258:
3371 case 0x260:
3372 fp->rate_max = fp->rate_min = 96000;
3373 break;
3374 default:
3375 snd_printk(KERN_ERR "unknown sample rate\n");
3376 kfree(fp);
3377 return -ENXIO;
3378 }
3379
3380 stream = (fp->endpoint & USB_DIR_IN)
3381 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3382 err = add_audio_endpoint(chip, stream, fp);
3383 if (err < 0) {
3384 kfree(fp);
3385 return err;
3386 }
3387 usb_set_interface(chip->dev, fp->iface, 0);
3388 return 0;
3389}
3390
3391static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3392 struct usb_interface *iface,
3393 const struct snd_usb_audio_quirk *quirk);
3394
3395/*
3396 * handle the quirks for the contained interfaces
3397 */
3398static int create_composite_quirk(struct snd_usb_audio *chip,
3399 struct usb_interface *iface,
3400 const struct snd_usb_audio_quirk *quirk)
3401{
3402 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
3403 int err;
3404
3405 for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) {
3406 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
3407 if (!iface)
3408 continue;
3409 if (quirk->ifnum != probed_ifnum &&
3410 usb_interface_claimed(iface))
3411 continue;
3412 err = snd_usb_create_quirk(chip, iface, quirk);
3413 if (err < 0)
3414 return err;
3415 if (quirk->ifnum != probed_ifnum)
3416 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
3417 }
3418 return 0;
3419}
3420
3421static int ignore_interface_quirk(struct snd_usb_audio *chip,
3422 struct usb_interface *iface,
3423 const struct snd_usb_audio_quirk *quirk)
3424{
3425 return 0;
3426}
3427
3428/*
3429 * Allow alignment on audio sub-slot (channel samples) rather than
3430 * on audio slots (audio frames)
3431 */
3432static int create_align_transfer_quirk(struct snd_usb_audio *chip,
3433 struct usb_interface *iface,
3434 const struct snd_usb_audio_quirk *quirk)
3435{
3436 chip->txfr_quirk = 1;
3437 return 1; /* Continue with creating streams and mixer */
3438}
3439
3440
3441/*
3442 * boot quirks
3443 */
3444
3445#define EXTIGY_FIRMWARE_SIZE_OLD 794
3446#define EXTIGY_FIRMWARE_SIZE_NEW 483
3447
3448static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
3449{
3450 struct usb_host_config *config = dev->actconfig;
3451 int err;
3452
3453 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
3454 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
3455 snd_printdd("sending Extigy boot sequence...\n");
3456 /* Send message to force it to reconnect with full interface. */
3457 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
3458 0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000);
3459 if (err < 0) snd_printdd("error sending boot message: %d\n", err);
3460 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
3461 &dev->descriptor, sizeof(dev->descriptor));
3462 config = dev->actconfig;
3463 if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
3464 err = usb_reset_configuration(dev);
3465 if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
3466 snd_printdd("extigy_boot: new boot length = %d\n",
3467 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
3468 return -ENODEV; /* quit this anyway */
3469 }
3470 return 0;
3471}
3472
3473static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
3474{
3475 u8 buf = 1;
3476
3477 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
3478 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3479 0, 0, &buf, 1, 1000);
3480 if (buf == 0) {
3481 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
3482 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3483 1, 2000, NULL, 0, 1000);
3484 return -ENODEV;
3485 }
3486 return 0;
3487}
3488
3489/*
3490 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
3491 * documented in the device's data sheet.
3492 */
3493static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
3494{
3495 u8 buf[4];
3496 buf[0] = 0x20;
3497 buf[1] = value & 0xff;
3498 buf[2] = (value >> 8) & 0xff;
3499 buf[3] = reg;
3500 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
3501 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
3502 0, 0, &buf, 4, 1000);
3503}
3504
3505static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
3506{
3507 /*
3508 * Enable line-out driver mode, set headphone source to front
3509 * channels, enable stereo mic.
3510 */
3511 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
3512}
3513
3514/*
3515 * C-Media CM6206 is based on CM106 with two additional
3516 * registers that are not documented in the data sheet.
3517 * Values here are chosen based on sniffing USB traffic
3518 * under Windows.
3519 */
3520static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
3521{
3522 int err, reg;
3523 int val[] = {0x200c, 0x3000, 0xf800, 0x143f, 0x0000, 0x3000};
3524
3525 for (reg = 0; reg < ARRAY_SIZE(val); reg++) {
3526 err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);
3527 if (err < 0)
3528 return err;
3529 }
3530
3531 return err;
3532}
3533
3534/*
3535 * This call will put the synth in "USB send" mode, i.e it will send MIDI
3536 * messages through USB (this is disabled at startup). The synth will
3537 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
3538 * sign on its LCD. Values here are chosen based on sniffing USB traffic
3539 * under Windows.
3540 */
3541static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
3542{
3543 int err, actual_length;
3544
3545 /* "midi send" enable */
3546 static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
3547
3548 void *buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
3549 if (!buf)
3550 return -ENOMEM;
3551 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
3552 ARRAY_SIZE(seq), &actual_length, 1000);
3553 kfree(buf);
3554 if (err < 0)
3555 return err;
3556
3557 return 0;
3558}
3559
3560/*
3561 * Setup quirks
3562 */
3563#define AUDIOPHILE_SET 0x01 /* if set, parse device_setup */
3564#define AUDIOPHILE_SET_DTS 0x02 /* if set, enable DTS Digital Output */
3565#define AUDIOPHILE_SET_96K 0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */
3566#define AUDIOPHILE_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */
3567#define AUDIOPHILE_SET_DI 0x10 /* if set, enable Digital Input */
3568#define AUDIOPHILE_SET_MASK 0x1F /* bit mask for setup value */
3569#define AUDIOPHILE_SET_24B_48K_DI 0x19 /* value for 24bits+48KHz+Digital Input */
3570#define AUDIOPHILE_SET_24B_48K_NOTDI 0x09 /* value for 24bits+48KHz+No Digital Input */
3571#define AUDIOPHILE_SET_16B_48K_DI 0x11 /* value for 16bits+48KHz+Digital Input */
3572#define AUDIOPHILE_SET_16B_48K_NOTDI 0x01 /* value for 16bits+48KHz+No Digital Input */
3573
3574static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
3575 int iface, int altno)
3576{
3577 /* Reset ALL ifaces to 0 altsetting.
3578 * Call it for every possible altsetting of every interface.
3579 */
3580 usb_set_interface(chip->dev, iface, 0);
3581
3582 if (device_setup[chip->index] & AUDIOPHILE_SET) {
3583 if ((device_setup[chip->index] & AUDIOPHILE_SET_DTS)
3584 && altno != 6)
3585 return 1; /* skip this altsetting */
3586 if ((device_setup[chip->index] & AUDIOPHILE_SET_96K)
3587 && altno != 1)
3588 return 1; /* skip this altsetting */
3589 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3590 AUDIOPHILE_SET_24B_48K_DI && altno != 2)
3591 return 1; /* skip this altsetting */
3592 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3593 AUDIOPHILE_SET_24B_48K_NOTDI && altno != 3)
3594 return 1; /* skip this altsetting */
3595 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3596 AUDIOPHILE_SET_16B_48K_DI && altno != 4)
3597 return 1; /* skip this altsetting */
3598 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3599 AUDIOPHILE_SET_16B_48K_NOTDI && altno != 5)
3600 return 1; /* skip this altsetting */
3601 }
3602 return 0; /* keep this altsetting */
3603}
3604
3605static int create_any_midi_quirk(struct snd_usb_audio *chip,
3606 struct usb_interface *intf,
3607 const struct snd_usb_audio_quirk *quirk)
3608{
3609 return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
3610}
3611
3612/*
3613 * audio-interface quirks
3614 *
3615 * returns zero if no standard audio/MIDI parsing is needed.
3616 * returns a postive value if standard audio/midi interfaces are parsed
3617 * after this.
3618 * returns a negative value at error.
3619 */
3620static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3621 struct usb_interface *iface,
3622 const struct snd_usb_audio_quirk *quirk)
3623{
3624 typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *,
3625 const struct snd_usb_audio_quirk *);
3626 static const quirk_func_t quirk_funcs[] = {
3627 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
3628 [QUIRK_COMPOSITE] = create_composite_quirk,
3629 [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
3630 [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
3631 [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
3632 [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
3633 [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
3634 [QUIRK_MIDI_FASTLANE] = create_any_midi_quirk,
3635 [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
3636 [QUIRK_MIDI_CME] = create_any_midi_quirk,
3637 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
3638 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
3639 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
3640 [QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk
3641 };
3642
3643 if (quirk->type < QUIRK_TYPE_COUNT) {
3644 return quirk_funcs[quirk->type](chip, iface, quirk);
3645 } else {
3646 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
3647 return -ENXIO;
3648 }
3649}
3650
3651
3652/*
3653 * common proc files to show the usb device info
3654 */
3655static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3656{
3657 struct snd_usb_audio *chip = entry->private_data;
3658 if (!chip->shutdown)
3659 snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
3660}
3661
3662static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3663{
3664 struct snd_usb_audio *chip = entry->private_data;
3665 if (!chip->shutdown)
3666 snd_iprintf(buffer, "%04x:%04x\n",
3667 USB_ID_VENDOR(chip->usb_id),
3668 USB_ID_PRODUCT(chip->usb_id));
3669}
3670
3671static void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
3672{
3673 struct snd_info_entry *entry;
3674 if (!snd_card_proc_new(chip->card, "usbbus", &entry))
3675 snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
3676 if (!snd_card_proc_new(chip->card, "usbid", &entry))
3677 snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
3678}
3679
3680/*
3681 * free the chip instance
3682 *
3683 * here we have to do not much, since pcm and controls are already freed
3684 *
3685 */
3686
3687static int snd_usb_audio_free(struct snd_usb_audio *chip)
3688{
3689 kfree(chip);
3690 return 0;
3691}
3692
3693static int snd_usb_audio_dev_free(struct snd_device *device)
3694{
3695 struct snd_usb_audio *chip = device->device_data;
3696 return snd_usb_audio_free(chip);
3697}
3698
3699
3700/*
3701 * create a chip instance and set its names.
3702 */
3703static int snd_usb_audio_create(struct usb_device *dev, int idx,
3704 const struct snd_usb_audio_quirk *quirk,
3705 struct snd_usb_audio **rchip)
3706{
3707 struct snd_card *card;
3708 struct snd_usb_audio *chip;
3709 int err, len;
3710 char component[14];
3711 static struct snd_device_ops ops = {
3712 .dev_free = snd_usb_audio_dev_free,
3713 };
3714
3715 *rchip = NULL;
3716
3717 if (snd_usb_get_speed(dev) != USB_SPEED_LOW &&
3718 snd_usb_get_speed(dev) != USB_SPEED_FULL &&
3719 snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
3720 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
3721 return -ENXIO;
3722 }
3723
3724 err = snd_card_create(index[idx], id[idx], THIS_MODULE, 0, &card);
3725 if (err < 0) {
3726 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
3727 return err;
3728 }
3729
3730 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
3731 if (! chip) {
3732 snd_card_free(card);
3733 return -ENOMEM;
3734 }
3735
3736 chip->index = idx;
3737 chip->dev = dev;
3738 chip->card = card;
3739 chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3740 le16_to_cpu(dev->descriptor.idProduct));
3741 INIT_LIST_HEAD(&chip->pcm_list);
3742 INIT_LIST_HEAD(&chip->midi_list);
3743 INIT_LIST_HEAD(&chip->mixer_list);
3744
3745 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
3746 snd_usb_audio_free(chip);
3747 snd_card_free(card);
3748 return err;
3749 }
3750
3751 strcpy(card->driver, "USB-Audio");
3752 sprintf(component, "USB%04x:%04x",
3753 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
3754 snd_component_add(card, component);
3755
3756 /* retrieve the device string as shortname */
3757 if (quirk && quirk->product_name) {
3758 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
3759 } else {
3760 if (!dev->descriptor.iProduct ||
3761 usb_string(dev, dev->descriptor.iProduct,
3762 card->shortname, sizeof(card->shortname)) <= 0) {
3763 /* no name available from anywhere, so use ID */
3764 sprintf(card->shortname, "USB Device %#04x:%#04x",
3765 USB_ID_VENDOR(chip->usb_id),
3766 USB_ID_PRODUCT(chip->usb_id));
3767 }
3768 }
3769
3770 /* retrieve the vendor and device strings as longname */
3771 if (quirk && quirk->vendor_name) {
3772 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
3773 } else {
3774 if (dev->descriptor.iManufacturer)
3775 len = usb_string(dev, dev->descriptor.iManufacturer,
3776 card->longname, sizeof(card->longname));
3777 else
3778 len = 0;
3779 /* we don't really care if there isn't any vendor string */
3780 }
3781 if (len > 0)
3782 strlcat(card->longname, " ", sizeof(card->longname));
3783
3784 strlcat(card->longname, card->shortname, sizeof(card->longname));
3785
3786 len = strlcat(card->longname, " at ", sizeof(card->longname));
3787
3788 if (len < sizeof(card->longname))
3789 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
3790
3791 strlcat(card->longname,
3792 snd_usb_get_speed(dev) == USB_SPEED_LOW ? ", low speed" :
3793 snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" :
3794 ", high speed",
3795 sizeof(card->longname));
3796
3797 snd_usb_audio_create_proc(chip);
3798
3799 *rchip = chip;
3800 return 0;
3801}
3802
3803
3804/*
3805 * probe the active usb device
3806 *
3807 * note that this can be called multiple times per a device, when it
3808 * includes multiple audio control interfaces.
3809 *
3810 * thus we check the usb device pointer and creates the card instance
3811 * only at the first time. the successive calls of this function will
3812 * append the pcm interface to the corresponding card.
3813 */
3814static void *snd_usb_audio_probe(struct usb_device *dev,
3815 struct usb_interface *intf,
3816 const struct usb_device_id *usb_id)
3817{
3818 const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info;
3819 int i, err;
3820 struct snd_usb_audio *chip;
3821 struct usb_host_interface *alts;
3822 int ifnum;
3823 u32 id;
3824
3825 alts = &intf->altsetting[0];
3826 ifnum = get_iface_desc(alts)->bInterfaceNumber;
3827 id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3828 le16_to_cpu(dev->descriptor.idProduct));
3829 if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
3830 goto __err_val;
3831
3832 /* SB Extigy needs special boot-up sequence */
3833 /* if more models come, this will go to the quirk list. */
3834 if (id == USB_ID(0x041e, 0x3000)) {
3835 if (snd_usb_extigy_boot_quirk(dev, intf) < 0)
3836 goto __err_val;
3837 }
3838 /* SB Audigy 2 NX needs its own boot-up magic, too */
3839 if (id == USB_ID(0x041e, 0x3020)) {
3840 if (snd_usb_audigy2nx_boot_quirk(dev) < 0)
3841 goto __err_val;
3842 }
3843
3844 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
3845 if (id == USB_ID(0x10f5, 0x0200)) {
3846 if (snd_usb_cm106_boot_quirk(dev) < 0)
3847 goto __err_val;
3848 }
3849
3850 /* C-Media CM6206 / CM106-Like Sound Device */
3851 if (id == USB_ID(0x0d8c, 0x0102)) {
3852 if (snd_usb_cm6206_boot_quirk(dev) < 0)
3853 goto __err_val;
3854 }
3855
3856 /* Access Music VirusTI Desktop */
3857 if (id == USB_ID(0x133e, 0x0815)) {
3858 if (snd_usb_accessmusic_boot_quirk(dev) < 0)
3859 goto __err_val;
3860 }
3861
3862 /*
3863 * found a config. now register to ALSA
3864 */
3865
3866 /* check whether it's already registered */
3867 chip = NULL;
3868 mutex_lock(&register_mutex);
3869 for (i = 0; i < SNDRV_CARDS; i++) {
3870 if (usb_chip[i] && usb_chip[i]->dev == dev) {
3871 if (usb_chip[i]->shutdown) {
3872 snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
3873 goto __error;
3874 }
3875 chip = usb_chip[i];
3876 break;
3877 }
3878 }
3879 if (! chip) {
3880 /* it's a fresh one.
3881 * now look for an empty slot and create a new card instance
3882 */
3883 for (i = 0; i < SNDRV_CARDS; i++)
3884 if (enable[i] && ! usb_chip[i] &&
3885 (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
3886 (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
3887 if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
3888 goto __error;
3889 }
3890 snd_card_set_dev(chip->card, &intf->dev);
3891 break;
3892 }
3893 if (!chip) {
3894 printk(KERN_ERR "no available usb audio device\n");
3895 goto __error;
3896 }
3897 }
3898
3899 chip->txfr_quirk = 0;
3900 err = 1; /* continue */
3901 if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
3902 /* need some special handlings */
3903 if ((err = snd_usb_create_quirk(chip, intf, quirk)) < 0)
3904 goto __error;
3905 }
3906
3907 if (err > 0) {
3908 /* create normal USB audio interfaces */
3909 if (snd_usb_create_streams(chip, ifnum) < 0 ||
3910 snd_usb_create_mixer(chip, ifnum, ignore_ctl_error) < 0) {
3911 goto __error;
3912 }
3913 }
3914
3915 /* we are allowed to call snd_card_register() many times */
3916 if (snd_card_register(chip->card) < 0) {
3917 goto __error;
3918 }
3919
3920 usb_chip[chip->index] = chip;
3921 chip->num_interfaces++;
3922 mutex_unlock(&register_mutex);
3923 return chip;
3924
3925 __error:
3926 if (chip && !chip->num_interfaces)
3927 snd_card_free(chip->card);
3928 mutex_unlock(&register_mutex);
3929 __err_val:
3930 return NULL;
3931}
3932
3933/*
3934 * we need to take care of counter, since disconnection can be called also
3935 * many times as well as usb_audio_probe().
3936 */
3937static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
3938{
3939 struct snd_usb_audio *chip;
3940 struct snd_card *card;
3941 struct list_head *p;
3942
3943 if (ptr == (void *)-1L)
3944 return;
3945
3946 chip = ptr;
3947 card = chip->card;
3948 mutex_lock(&register_mutex);
3949 chip->shutdown = 1;
3950 chip->num_interfaces--;
3951 if (chip->num_interfaces <= 0) {
3952 snd_card_disconnect(card);
3953 /* release the pcm resources */
3954 list_for_each(p, &chip->pcm_list) {
3955 snd_usb_stream_disconnect(p);
3956 }
3957 /* release the midi resources */
3958 list_for_each(p, &chip->midi_list) {
3959 snd_usbmidi_disconnect(p);
3960 }
3961 /* release mixer resources */
3962 list_for_each(p, &chip->mixer_list) {
3963 snd_usb_mixer_disconnect(p);
3964 }
3965 usb_chip[chip->index] = NULL;
3966 mutex_unlock(&register_mutex);
3967 snd_card_free_when_closed(card);
3968 } else {
3969 mutex_unlock(&register_mutex);
3970 }
3971}
3972
3973/*
3974 * new 2.5 USB kernel API
3975 */
3976static int usb_audio_probe(struct usb_interface *intf,
3977 const struct usb_device_id *id)
3978{
3979 void *chip;
3980 chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
3981 if (chip) {
3982 usb_set_intfdata(intf, chip);
3983 return 0;
3984 } else
3985 return -EIO;
3986}
3987
3988static void usb_audio_disconnect(struct usb_interface *intf)
3989{
3990 snd_usb_audio_disconnect(interface_to_usbdev(intf),
3991 usb_get_intfdata(intf));
3992}
3993
3994#ifdef CONFIG_PM
3995static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
3996{
3997 struct snd_usb_audio *chip = usb_get_intfdata(intf);
3998 struct list_head *p;
3999 struct snd_usb_stream *as;
4000
4001 if (chip == (void *)-1L)
4002 return 0;
4003
4004 snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
4005 if (!chip->num_suspended_intf++) {
4006 list_for_each(p, &chip->pcm_list) {
4007 as = list_entry(p, struct snd_usb_stream, list);
4008 snd_pcm_suspend_all(as->pcm);
4009 }
4010 }
4011
4012 return 0;
4013}
4014
4015static int usb_audio_resume(struct usb_interface *intf)
4016{
4017 struct snd_usb_audio *chip = usb_get_intfdata(intf);
4018
4019 if (chip == (void *)-1L)
4020 return 0;
4021 if (--chip->num_suspended_intf)
4022 return 0;
4023 /*
4024 * ALSA leaves material resumption to user space
4025 * we just notify
4026 */
4027
4028 snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
4029
4030 return 0;
4031}
4032#endif /* CONFIG_PM */
4033
4034static int __init snd_usb_audio_init(void)
4035{
4036 if (nrpacks < 1 || nrpacks > MAX_PACKS) {
4037 printk(KERN_WARNING "invalid nrpacks value.\n");
4038 return -EINVAL;
4039 }
4040 return usb_register(&usb_audio_driver);
4041}
4042
4043
4044static void __exit snd_usb_audio_cleanup(void)
4045{
4046 usb_deregister(&usb_audio_driver);
4047}
4048
4049module_init(snd_usb_audio_init);
4050module_exit(snd_usb_audio_cleanup);
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index 42c299cbf63a..d679e72a3e5c 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -21,15 +21,13 @@
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */ 22 */
23 23
24/* maximum number of endpoints per interface */
25#define MIDI_MAX_ENDPOINTS 2
26
27/* handling of USB vendor/product ID pairs as 32-bit numbers */ 24/* handling of USB vendor/product ID pairs as 32-bit numbers */
28#define USB_ID(vendor, product) (((vendor) << 16) | (product)) 25#define USB_ID(vendor, product) (((vendor) << 16) | (product))
29#define USB_ID_VENDOR(id) ((id) >> 16) 26#define USB_ID_VENDOR(id) ((id) >> 16)
30#define USB_ID_PRODUCT(id) ((u16)(id)) 27#define USB_ID_PRODUCT(id) ((u16)(id))
31 28
32/* 29/*
30 *
33 */ 31 */
34 32
35struct snd_usb_audio { 33struct snd_usb_audio {
@@ -51,6 +49,10 @@ struct snd_usb_audio {
51 struct list_head midi_list; /* list of midi interfaces */ 49 struct list_head midi_list; /* list of midi interfaces */
52 50
53 struct list_head mixer_list; /* list of mixer interfaces */ 51 struct list_head mixer_list; /* list of mixer interfaces */
52
53 int setup; /* from the 'device_setup' module param */
54 int nrpacks; /* from the 'nrpacks' module param */
55 int async_unlink; /* from the 'async_unlink' module param */
54}; 56};
55 57
56/* 58/*
@@ -89,93 +91,8 @@ struct snd_usb_audio_quirk {
89 const void *data; 91 const void *data;
90}; 92};
91 93
92/* data for QUIRK_MIDI_FIXED_ENDPOINT */
93struct snd_usb_midi_endpoint_info {
94 int8_t out_ep; /* ep number, 0 autodetect */
95 uint8_t out_interval; /* interval for interrupt endpoints */
96 int8_t in_ep;
97 uint8_t in_interval;
98 uint16_t out_cables; /* bitmask */
99 uint16_t in_cables; /* bitmask */
100};
101
102/* for QUIRK_MIDI_YAMAHA, data is NULL */
103
104/* for QUIRK_MIDI_MIDIMAN, data points to a snd_usb_midi_endpoint_info
105 * structure (out_cables and in_cables only) */
106
107/* for QUIRK_COMPOSITE, data points to an array of snd_usb_audio_quirk
108 * structures, terminated with .ifnum = -1 */
109
110/* for QUIRK_AUDIO_FIXED_ENDPOINT, data points to an audioformat structure */
111
112/* for QUIRK_AUDIO/MIDI_STANDARD_INTERFACE, data is NULL */
113
114/* for QUIRK_AUDIO_EDIROL_UAXX, data is NULL */
115
116/* for QUIRK_IGNORE_INTERFACE, data is NULL */
117
118/* for QUIRK_MIDI_NOVATION and _RAW, data is NULL */
119
120/* for QUIRK_MIDI_EMAGIC, data points to a snd_usb_midi_endpoint_info
121 * structure (out_cables and in_cables only) */
122
123/* for QUIRK_MIDI_CME, data is NULL */
124
125/*
126 */
127
128/*E-mu USB samplerate control quirk*/
129enum {
130 EMU_QUIRK_SR_44100HZ = 0,
131 EMU_QUIRK_SR_48000HZ,
132 EMU_QUIRK_SR_88200HZ,
133 EMU_QUIRK_SR_96000HZ,
134 EMU_QUIRK_SR_176400HZ,
135 EMU_QUIRK_SR_192000HZ
136};
137
138#define combine_word(s) ((*(s)) | ((unsigned int)(s)[1] << 8)) 94#define combine_word(s) ((*(s)) | ((unsigned int)(s)[1] << 8))
139#define combine_triple(s) (combine_word(s) | ((unsigned int)(s)[2] << 16)) 95#define combine_triple(s) (combine_word(s) | ((unsigned int)(s)[2] << 16))
140#define combine_quad(s) (combine_triple(s) | ((unsigned int)(s)[3] << 24)) 96#define combine_quad(s) (combine_triple(s) | ((unsigned int)(s)[3] << 24))
141 97
142unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size);
143
144void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype);
145void *snd_usb_find_csint_desc(void *descstart, int desclen, void *after, u8 dsubtype);
146
147int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe,
148 __u8 request, __u8 requesttype, __u16 value, __u16 index,
149 void *data, __u16 size, int timeout);
150
151int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
152 int ignore_error);
153void snd_usb_mixer_disconnect(struct list_head *p);
154
155int snd_usbmidi_create(struct snd_card *card,
156 struct usb_interface *iface,
157 struct list_head *midi_list,
158 const struct snd_usb_audio_quirk *quirk);
159void snd_usbmidi_input_stop(struct list_head* p);
160void snd_usbmidi_input_start(struct list_head* p);
161void snd_usbmidi_disconnect(struct list_head *p);
162
163void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
164 unsigned char samplerate_id);
165
166/*
167 * retrieve usb_interface descriptor from the host interface
168 * (conditional for compatibility with the older API)
169 */
170#ifndef get_iface_desc
171#define get_iface_desc(iface) (&(iface)->desc)
172#define get_endpoint(alt,ep) (&(alt)->endpoint[ep].desc)
173#define get_ep_desc(ep) (&(ep)->desc)
174#define get_cfg_desc(cfg) (&(cfg)->desc)
175#endif
176
177#ifndef snd_usb_get_speed
178#define snd_usb_get_speed(dev) ((dev)->speed)
179#endif
180
181#endif /* __USBAUDIO_H */ 98#endif /* __USBAUDIO_H */
diff --git a/sound/usb/usx2y/us122l.c b/sound/usb/usx2y/us122l.c
index 9ca9a13a78da..6ef68e42138e 100644
--- a/sound/usb/usx2y/us122l.c
+++ b/sound/usb/usx2y/us122l.c
@@ -26,6 +26,7 @@
26#define MODNAME "US122L" 26#define MODNAME "US122L"
27#include "usb_stream.c" 27#include "usb_stream.c"
28#include "../usbaudio.h" 28#include "../usbaudio.h"
29#include "../midi.h"
29#include "us122l.h" 30#include "us122l.h"
30 31
31MODULE_AUTHOR("Karsten Wiese <fzu@wemgehoertderstaat.de>"); 32MODULE_AUTHOR("Karsten Wiese <fzu@wemgehoertderstaat.de>");
diff --git a/sound/usb/usx2y/usbusx2y.h b/sound/usb/usx2y/usbusx2y.h
index 1d174cea352b..e43c0a86441a 100644
--- a/sound/usb/usx2y/usbusx2y.h
+++ b/sound/usb/usx2y/usbusx2y.h
@@ -1,6 +1,7 @@
1#ifndef USBUSX2Y_H 1#ifndef USBUSX2Y_H
2#define USBUSX2Y_H 2#define USBUSX2Y_H
3#include "../usbaudio.h" 3#include "../usbaudio.h"
4#include "../midi.h"
4#include "usbus428ctldefs.h" 5#include "usbus428ctldefs.h"
5 6
6#define NRURBS 2 7#define NRURBS 2
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-05 16:43:39 -0500