Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 92b9ac78f934616d08c72747607bfb0fa51ee52d

Authored by Clemens Ladisch
Committed by Jaroslav Kysela
1 parent eb995a8c82
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

[ALSA] usb-audio: increase number of packets per URB 

To decrease the USB interrupts rate, increase both the default and the
maximum number of packets per URB.

Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Jaroslav Kysela <perex@suse.cz>

Showing 1 changed file with 2 additions and 2 deletions Inline Diff

sound/usb/usbaudio.c
Diff comments   View file @ 92b9ac7
1 /* 1 /*
2 * (Tentative) USB Audio Driver for ALSA 2 * (Tentative) USB Audio Driver for ALSA
3 * 3 *
4 * Main and PCM part 4 * Main and PCM part
5 * 5 *
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de> 6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7 * 7 *
8 * Many codes borrowed from audio.c by 8 * Many codes borrowed from audio.c by
9 * Alan Cox (alan@lxorguk.ukuu.org.uk) 9 * Alan Cox (alan@lxorguk.ukuu.org.uk)
10 * Thomas Sailer (sailer@ife.ee.ethz.ch) 10 * Thomas Sailer (sailer@ife.ee.ethz.ch)
11 * 11 *
12 * 12 *
13 * This program is free software; you can redistribute it and/or modify 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 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 15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version. 16 * (at your option) any later version.
17 * 17 *
18 * This program is distributed in the hope that it will be useful, 18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details. 21 * GNU General Public License for more details.
22 * 22 *
23 * You should have received a copy of the GNU General Public License 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 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 25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 * 26 *
27 * 27 *
28 * NOTES: 28 * NOTES:
29 * 29 *
30 * - async unlink should be used for avoiding the sleep inside lock. 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 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. 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 33 * - the linked URBs would be preferred but not used so far because of
34 * the instability of unlinking. 34 * the instability of unlinking.
35 * - type II is not supported properly. there is no device which supports 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 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). 37 * indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
38 */ 38 */
39 39
40 40
41 #include <sound/driver.h> 41 #include <sound/driver.h>
42 #include <linux/bitops.h> 42 #include <linux/bitops.h>
43 #include <linux/init.h> 43 #include <linux/init.h>
44 #include <linux/list.h> 44 #include <linux/list.h>
45 #include <linux/slab.h> 45 #include <linux/slab.h>
46 #include <linux/string.h> 46 #include <linux/string.h>
47 #include <linux/usb.h> 47 #include <linux/usb.h>
48 #include <linux/vmalloc.h> 48 #include <linux/vmalloc.h>
49 #include <linux/moduleparam.h> 49 #include <linux/moduleparam.h>
50 #include <linux/mutex.h> 50 #include <linux/mutex.h>
51 #include <sound/core.h> 51 #include <sound/core.h>
52 #include <sound/info.h> 52 #include <sound/info.h>
53 #include <sound/pcm.h> 53 #include <sound/pcm.h>
54 #include <sound/pcm_params.h> 54 #include <sound/pcm_params.h>
55 #include <sound/initval.h> 55 #include <sound/initval.h>
56 56
57 #include "usbaudio.h" 57 #include "usbaudio.h"
58 58
59 59
60 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); 60 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
61 MODULE_DESCRIPTION("USB Audio"); 61 MODULE_DESCRIPTION("USB Audio");
62 MODULE_LICENSE("GPL"); 62 MODULE_LICENSE("GPL");
63 MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}"); 63 MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
64 64
65 65
66 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 66 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
67 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 67 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
68 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ 68 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
69 static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Vendor ID for this card */ 69 static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Vendor ID for this card */
70 static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Product ID for this card */ 70 static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Product ID for this card */
71 static int nrpacks = 4; /* max. number of packets per urb */ 71 static int nrpacks = 8; /* max. number of packets per urb */
72 static int async_unlink = 1; 72 static int async_unlink = 1;
73 static int device_setup[SNDRV_CARDS]; /* device parameter for this card*/ 73 static int device_setup[SNDRV_CARDS]; /* device parameter for this card*/
74 74
75 module_param_array(index, int, NULL, 0444); 75 module_param_array(index, int, NULL, 0444);
76 MODULE_PARM_DESC(index, "Index value for the USB audio adapter."); 76 MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
77 module_param_array(id, charp, NULL, 0444); 77 module_param_array(id, charp, NULL, 0444);
78 MODULE_PARM_DESC(id, "ID string for the USB audio adapter."); 78 MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
79 module_param_array(enable, bool, NULL, 0444); 79 module_param_array(enable, bool, NULL, 0444);
80 MODULE_PARM_DESC(enable, "Enable USB audio adapter."); 80 MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
81 module_param_array(vid, int, NULL, 0444); 81 module_param_array(vid, int, NULL, 0444);
82 MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device."); 82 MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
83 module_param_array(pid, int, NULL, 0444); 83 module_param_array(pid, int, NULL, 0444);
84 MODULE_PARM_DESC(pid, "Product ID for the USB audio device."); 84 MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
85 module_param(nrpacks, int, 0644); 85 module_param(nrpacks, int, 0644);
86 MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB."); 86 MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
87 module_param(async_unlink, bool, 0444); 87 module_param(async_unlink, bool, 0444);
88 MODULE_PARM_DESC(async_unlink, "Use async unlink mode."); 88 MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
89 module_param_array(device_setup, int, NULL, 0444); 89 module_param_array(device_setup, int, NULL, 0444);
90 MODULE_PARM_DESC(device_setup, "Specific device setup (if needed)."); 90 MODULE_PARM_DESC(device_setup, "Specific device setup (if needed).");
91 91
92 92
93 /* 93 /*
94 * debug the h/w constraints 94 * debug the h/w constraints
95 */ 95 */
96 /* #define HW_CONST_DEBUG */ 96 /* #define HW_CONST_DEBUG */
97 97
98 98
99 /* 99 /*
100 * 100 *
101 */ 101 */
102 102
103 #define MAX_PACKS 10 103 #define MAX_PACKS 20
104 #define MAX_PACKS_HS (MAX_PACKS * 8) /* in high speed mode */ 104 #define MAX_PACKS_HS (MAX_PACKS * 8) /* in high speed mode */
105 #define MAX_URBS 8 105 #define MAX_URBS 8
106 #define SYNC_URBS 4 /* always four urbs for sync */ 106 #define SYNC_URBS 4 /* always four urbs for sync */
107 #define MIN_PACKS_URB 1 /* minimum 1 packet per urb */ 107 #define MIN_PACKS_URB 1 /* minimum 1 packet per urb */
108 108
109 struct audioformat { 109 struct audioformat {
110 struct list_head list; 110 struct list_head list;
111 snd_pcm_format_t format; /* format type */ 111 snd_pcm_format_t format; /* format type */
112 unsigned int channels; /* # channels */ 112 unsigned int channels; /* # channels */
113 unsigned int fmt_type; /* USB audio format type (1-3) */ 113 unsigned int fmt_type; /* USB audio format type (1-3) */
114 unsigned int frame_size; /* samples per frame for non-audio */ 114 unsigned int frame_size; /* samples per frame for non-audio */
115 int iface; /* interface number */ 115 int iface; /* interface number */
116 unsigned char altsetting; /* corresponding alternate setting */ 116 unsigned char altsetting; /* corresponding alternate setting */
117 unsigned char altset_idx; /* array index of altenate setting */ 117 unsigned char altset_idx; /* array index of altenate setting */
118 unsigned char attributes; /* corresponding attributes of cs endpoint */ 118 unsigned char attributes; /* corresponding attributes of cs endpoint */
119 unsigned char endpoint; /* endpoint */ 119 unsigned char endpoint; /* endpoint */
120 unsigned char ep_attr; /* endpoint attributes */ 120 unsigned char ep_attr; /* endpoint attributes */
121 unsigned int maxpacksize; /* max. packet size */ 121 unsigned int maxpacksize; /* max. packet size */
122 unsigned int rates; /* rate bitmasks */ 122 unsigned int rates; /* rate bitmasks */
123 unsigned int rate_min, rate_max; /* min/max rates */ 123 unsigned int rate_min, rate_max; /* min/max rates */
124 unsigned int nr_rates; /* number of rate table entries */ 124 unsigned int nr_rates; /* number of rate table entries */
125 unsigned int *rate_table; /* rate table */ 125 unsigned int *rate_table; /* rate table */
126 unsigned int needs_knot; /* any unusual rates? */ 126 unsigned int needs_knot; /* any unusual rates? */
127 }; 127 };
128 128
129 struct snd_usb_substream; 129 struct snd_usb_substream;
130 130
131 struct snd_urb_ctx { 131 struct snd_urb_ctx {
132 struct urb *urb; 132 struct urb *urb;
133 unsigned int buffer_size; /* size of data buffer, if data URB */ 133 unsigned int buffer_size; /* size of data buffer, if data URB */
134 struct snd_usb_substream *subs; 134 struct snd_usb_substream *subs;
135 int index; /* index for urb array */ 135 int index; /* index for urb array */
136 int packets; /* number of packets per urb */ 136 int packets; /* number of packets per urb */
137 }; 137 };
138 138
139 struct snd_urb_ops { 139 struct snd_urb_ops {
140 int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); 140 int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
141 int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); 141 int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
142 int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); 142 int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
143 int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); 143 int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
144 }; 144 };
145 145
146 struct snd_usb_substream { 146 struct snd_usb_substream {
147 struct snd_usb_stream *stream; 147 struct snd_usb_stream *stream;
148 struct usb_device *dev; 148 struct usb_device *dev;
149 struct snd_pcm_substream *pcm_substream; 149 struct snd_pcm_substream *pcm_substream;
150 int direction; /* playback or capture */ 150 int direction; /* playback or capture */
151 int interface; /* current interface */ 151 int interface; /* current interface */
152 int endpoint; /* assigned endpoint */ 152 int endpoint; /* assigned endpoint */
153 struct audioformat *cur_audiofmt; /* current audioformat pointer (for hw_params callback) */ 153 struct audioformat *cur_audiofmt; /* current audioformat pointer (for hw_params callback) */
154 unsigned int cur_rate; /* current rate (for hw_params callback) */ 154 unsigned int cur_rate; /* current rate (for hw_params callback) */
155 unsigned int period_bytes; /* current period bytes (for hw_params callback) */ 155 unsigned int period_bytes; /* current period bytes (for hw_params callback) */
156 unsigned int format; /* USB data format */ 156 unsigned int format; /* USB data format */
157 unsigned int datapipe; /* the data i/o pipe */ 157 unsigned int datapipe; /* the data i/o pipe */
158 unsigned int syncpipe; /* 1 - async out or adaptive in */ 158 unsigned int syncpipe; /* 1 - async out or adaptive in */
159 unsigned int datainterval; /* log_2 of data packet interval */ 159 unsigned int datainterval; /* log_2 of data packet interval */
160 unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */ 160 unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */
161 unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */ 161 unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */
162 unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */ 162 unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */
163 unsigned int freqmax; /* maximum sampling rate, used for buffer management */ 163 unsigned int freqmax; /* maximum sampling rate, used for buffer management */
164 unsigned int phase; /* phase accumulator */ 164 unsigned int phase; /* phase accumulator */
165 unsigned int maxpacksize; /* max packet size in bytes */ 165 unsigned int maxpacksize; /* max packet size in bytes */
166 unsigned int maxframesize; /* max packet size in frames */ 166 unsigned int maxframesize; /* max packet size in frames */
167 unsigned int curpacksize; /* current packet size in bytes (for capture) */ 167 unsigned int curpacksize; /* current packet size in bytes (for capture) */
168 unsigned int curframesize; /* current packet size in frames (for capture) */ 168 unsigned int curframesize; /* current packet size in frames (for capture) */
169 unsigned int fill_max: 1; /* fill max packet size always */ 169 unsigned int fill_max: 1; /* fill max packet size always */
170 unsigned int fmt_type; /* USB audio format type (1-3) */ 170 unsigned int fmt_type; /* USB audio format type (1-3) */
171 unsigned int packs_per_ms; /* packets per millisecond (for playback) */ 171 unsigned int packs_per_ms; /* packets per millisecond (for playback) */
172 172
173 unsigned int running: 1; /* running status */ 173 unsigned int running: 1; /* running status */
174 174
175 unsigned int hwptr_done; /* processed frame position in the buffer */ 175 unsigned int hwptr_done; /* processed frame position in the buffer */
176 unsigned int transfer_done; /* processed frames since last period update */ 176 unsigned int transfer_done; /* processed frames since last period update */
177 unsigned long active_mask; /* bitmask of active urbs */ 177 unsigned long active_mask; /* bitmask of active urbs */
178 unsigned long unlink_mask; /* bitmask of unlinked urbs */ 178 unsigned long unlink_mask; /* bitmask of unlinked urbs */
179 179
180 unsigned int nurbs; /* # urbs */ 180 unsigned int nurbs; /* # urbs */
181 struct snd_urb_ctx dataurb[MAX_URBS]; /* data urb table */ 181 struct snd_urb_ctx dataurb[MAX_URBS]; /* data urb table */
182 struct snd_urb_ctx syncurb[SYNC_URBS]; /* sync urb table */ 182 struct snd_urb_ctx syncurb[SYNC_URBS]; /* sync urb table */
183 char *syncbuf; /* sync buffer for all sync URBs */ 183 char *syncbuf; /* sync buffer for all sync URBs */
184 dma_addr_t sync_dma; /* DMA address of syncbuf */ 184 dma_addr_t sync_dma; /* DMA address of syncbuf */
185 185
186 u64 formats; /* format bitmasks (all or'ed) */ 186 u64 formats; /* format bitmasks (all or'ed) */
187 unsigned int num_formats; /* number of supported audio formats (list) */ 187 unsigned int num_formats; /* number of supported audio formats (list) */
188 struct list_head fmt_list; /* format list */ 188 struct list_head fmt_list; /* format list */
189 spinlock_t lock; 189 spinlock_t lock;
190 190
191 struct snd_urb_ops ops; /* callbacks (must be filled at init) */ 191 struct snd_urb_ops ops; /* callbacks (must be filled at init) */
192 }; 192 };
193 193
194 194
195 struct snd_usb_stream { 195 struct snd_usb_stream {
196 struct snd_usb_audio *chip; 196 struct snd_usb_audio *chip;
197 struct snd_pcm *pcm; 197 struct snd_pcm *pcm;
198 int pcm_index; 198 int pcm_index;
199 unsigned int fmt_type; /* USB audio format type (1-3) */ 199 unsigned int fmt_type; /* USB audio format type (1-3) */
200 struct snd_usb_substream substream[2]; 200 struct snd_usb_substream substream[2];
201 struct list_head list; 201 struct list_head list;
202 }; 202 };
203 203
204 204
205 /* 205 /*
206 * we keep the snd_usb_audio_t instances by ourselves for merging 206 * we keep the snd_usb_audio_t instances by ourselves for merging
207 * the all interfaces on the same card as one sound device. 207 * the all interfaces on the same card as one sound device.
208 */ 208 */
209 209
210 static DEFINE_MUTEX(register_mutex); 210 static DEFINE_MUTEX(register_mutex);
211 static struct snd_usb_audio *usb_chip[SNDRV_CARDS]; 211 static struct snd_usb_audio *usb_chip[SNDRV_CARDS];
212 212
213 213
214 /* 214 /*
215 * convert a sampling rate into our full speed format (fs/1000 in Q16.16) 215 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
216 * this will overflow at approx 524 kHz 216 * this will overflow at approx 524 kHz
217 */ 217 */
218 static inline unsigned get_usb_full_speed_rate(unsigned int rate) 218 static inline unsigned get_usb_full_speed_rate(unsigned int rate)
219 { 219 {
220 return ((rate << 13) + 62) / 125; 220 return ((rate << 13) + 62) / 125;
221 } 221 }
222 222
223 /* 223 /*
224 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16) 224 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
225 * this will overflow at approx 4 MHz 225 * this will overflow at approx 4 MHz
226 */ 226 */
227 static inline unsigned get_usb_high_speed_rate(unsigned int rate) 227 static inline unsigned get_usb_high_speed_rate(unsigned int rate)
228 { 228 {
229 return ((rate << 10) + 62) / 125; 229 return ((rate << 10) + 62) / 125;
230 } 230 }
231 231
232 /* convert our full speed USB rate into sampling rate in Hz */ 232 /* convert our full speed USB rate into sampling rate in Hz */
233 static inline unsigned get_full_speed_hz(unsigned int usb_rate) 233 static inline unsigned get_full_speed_hz(unsigned int usb_rate)
234 { 234 {
235 return (usb_rate * 125 + (1 << 12)) >> 13; 235 return (usb_rate * 125 + (1 << 12)) >> 13;
236 } 236 }
237 237
238 /* convert our high speed USB rate into sampling rate in Hz */ 238 /* convert our high speed USB rate into sampling rate in Hz */
239 static inline unsigned get_high_speed_hz(unsigned int usb_rate) 239 static inline unsigned get_high_speed_hz(unsigned int usb_rate)
240 { 240 {
241 return (usb_rate * 125 + (1 << 9)) >> 10; 241 return (usb_rate * 125 + (1 << 9)) >> 10;
242 } 242 }
243 243
244 244
245 /* 245 /*
246 * prepare urb for full speed capture sync pipe 246 * prepare urb for full speed capture sync pipe
247 * 247 *
248 * fill the length and offset of each urb descriptor. 248 * fill the length and offset of each urb descriptor.
249 * the fixed 10.14 frequency is passed through the pipe. 249 * the fixed 10.14 frequency is passed through the pipe.
250 */ 250 */
251 static int prepare_capture_sync_urb(struct snd_usb_substream *subs, 251 static int prepare_capture_sync_urb(struct snd_usb_substream *subs,
252 struct snd_pcm_runtime *runtime, 252 struct snd_pcm_runtime *runtime,
253 struct urb *urb) 253 struct urb *urb)
254 { 254 {
255 unsigned char *cp = urb->transfer_buffer; 255 unsigned char *cp = urb->transfer_buffer;
256 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 256 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
257 257
258 urb->dev = ctx->subs->dev; /* we need to set this at each time */ 258 urb->dev = ctx->subs->dev; /* we need to set this at each time */
259 urb->iso_frame_desc[0].length = 3; 259 urb->iso_frame_desc[0].length = 3;
260 urb->iso_frame_desc[0].offset = 0; 260 urb->iso_frame_desc[0].offset = 0;
261 cp[0] = subs->freqn >> 2; 261 cp[0] = subs->freqn >> 2;
262 cp[1] = subs->freqn >> 10; 262 cp[1] = subs->freqn >> 10;
263 cp[2] = subs->freqn >> 18; 263 cp[2] = subs->freqn >> 18;
264 return 0; 264 return 0;
265 } 265 }
266 266
267 /* 267 /*
268 * prepare urb for high speed capture sync pipe 268 * prepare urb for high speed capture sync pipe
269 * 269 *
270 * fill the length and offset of each urb descriptor. 270 * fill the length and offset of each urb descriptor.
271 * the fixed 12.13 frequency is passed as 16.16 through the pipe. 271 * the fixed 12.13 frequency is passed as 16.16 through the pipe.
272 */ 272 */
273 static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs, 273 static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs,
274 struct snd_pcm_runtime *runtime, 274 struct snd_pcm_runtime *runtime,
275 struct urb *urb) 275 struct urb *urb)
276 { 276 {
277 unsigned char *cp = urb->transfer_buffer; 277 unsigned char *cp = urb->transfer_buffer;
278 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 278 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
279 279
280 urb->dev = ctx->subs->dev; /* we need to set this at each time */ 280 urb->dev = ctx->subs->dev; /* we need to set this at each time */
281 urb->iso_frame_desc[0].length = 4; 281 urb->iso_frame_desc[0].length = 4;
282 urb->iso_frame_desc[0].offset = 0; 282 urb->iso_frame_desc[0].offset = 0;
283 cp[0] = subs->freqn; 283 cp[0] = subs->freqn;
284 cp[1] = subs->freqn >> 8; 284 cp[1] = subs->freqn >> 8;
285 cp[2] = subs->freqn >> 16; 285 cp[2] = subs->freqn >> 16;
286 cp[3] = subs->freqn >> 24; 286 cp[3] = subs->freqn >> 24;
287 return 0; 287 return 0;
288 } 288 }
289 289
290 /* 290 /*
291 * process after capture sync complete 291 * process after capture sync complete
292 * - nothing to do 292 * - nothing to do
293 */ 293 */
294 static int retire_capture_sync_urb(struct snd_usb_substream *subs, 294 static int retire_capture_sync_urb(struct snd_usb_substream *subs,
295 struct snd_pcm_runtime *runtime, 295 struct snd_pcm_runtime *runtime,
296 struct urb *urb) 296 struct urb *urb)
297 { 297 {
298 return 0; 298 return 0;
299 } 299 }
300 300
301 /* 301 /*
302 * prepare urb for capture data pipe 302 * prepare urb for capture data pipe
303 * 303 *
304 * fill the offset and length of each descriptor. 304 * fill the offset and length of each descriptor.
305 * 305 *
306 * we use a temporary buffer to write the captured data. 306 * we use a temporary buffer to write the captured data.
307 * since the length of written data is determined by host, we cannot 307 * since the length of written data is determined by host, we cannot
308 * write onto the pcm buffer directly... the data is thus copied 308 * write onto the pcm buffer directly... the data is thus copied
309 * later at complete callback to the global buffer. 309 * later at complete callback to the global buffer.
310 */ 310 */
311 static int prepare_capture_urb(struct snd_usb_substream *subs, 311 static int prepare_capture_urb(struct snd_usb_substream *subs,
312 struct snd_pcm_runtime *runtime, 312 struct snd_pcm_runtime *runtime,
313 struct urb *urb) 313 struct urb *urb)
314 { 314 {
315 int i, offs; 315 int i, offs;
316 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 316 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
317 317
318 offs = 0; 318 offs = 0;
319 urb->dev = ctx->subs->dev; /* we need to set this at each time */ 319 urb->dev = ctx->subs->dev; /* we need to set this at each time */
320 for (i = 0; i < ctx->packets; i++) { 320 for (i = 0; i < ctx->packets; i++) {
321 urb->iso_frame_desc[i].offset = offs; 321 urb->iso_frame_desc[i].offset = offs;
322 urb->iso_frame_desc[i].length = subs->curpacksize; 322 urb->iso_frame_desc[i].length = subs->curpacksize;
323 offs += subs->curpacksize; 323 offs += subs->curpacksize;
324 } 324 }
325 urb->transfer_buffer_length = offs; 325 urb->transfer_buffer_length = offs;
326 urb->number_of_packets = ctx->packets; 326 urb->number_of_packets = ctx->packets;
327 #if 0 // for check 327 #if 0 // for check
328 if (! urb->bandwidth) { 328 if (! urb->bandwidth) {
329 int bustime; 329 int bustime;
330 bustime = usb_check_bandwidth(urb->dev, urb); 330 bustime = usb_check_bandwidth(urb->dev, urb);
331 if (bustime < 0) 331 if (bustime < 0)
332 return bustime; 332 return bustime;
333 printk("urb %d: bandwidth = %d (packets = %d)\n", ctx->index, bustime, urb->number_of_packets); 333 printk("urb %d: bandwidth = %d (packets = %d)\n", ctx->index, bustime, urb->number_of_packets);
334 usb_claim_bandwidth(urb->dev, urb, bustime, 1); 334 usb_claim_bandwidth(urb->dev, urb, bustime, 1);
335 } 335 }
336 #endif // for check 336 #endif // for check
337 return 0; 337 return 0;
338 } 338 }
339 339
340 /* 340 /*
341 * process after capture complete 341 * process after capture complete
342 * 342 *
343 * copy the data from each desctiptor to the pcm buffer, and 343 * copy the data from each desctiptor to the pcm buffer, and
344 * update the current position. 344 * update the current position.
345 */ 345 */
346 static int retire_capture_urb(struct snd_usb_substream *subs, 346 static int retire_capture_urb(struct snd_usb_substream *subs,
347 struct snd_pcm_runtime *runtime, 347 struct snd_pcm_runtime *runtime,
348 struct urb *urb) 348 struct urb *urb)
349 { 349 {
350 unsigned long flags; 350 unsigned long flags;
351 unsigned char *cp; 351 unsigned char *cp;
352 int i; 352 int i;
353 unsigned int stride, len, oldptr; 353 unsigned int stride, len, oldptr;
354 int period_elapsed = 0; 354 int period_elapsed = 0;
355 355
356 stride = runtime->frame_bits >> 3; 356 stride = runtime->frame_bits >> 3;
357 357
358 for (i = 0; i < urb->number_of_packets; i++) { 358 for (i = 0; i < urb->number_of_packets; i++) {
359 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset; 359 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
360 if (urb->iso_frame_desc[i].status) { 360 if (urb->iso_frame_desc[i].status) {
361 snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status); 361 snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
362 // continue; 362 // continue;
363 } 363 }
364 len = urb->iso_frame_desc[i].actual_length / stride; 364 len = urb->iso_frame_desc[i].actual_length / stride;
365 if (! len) 365 if (! len)
366 continue; 366 continue;
367 /* update the current pointer */ 367 /* update the current pointer */
368 spin_lock_irqsave(&subs->lock, flags); 368 spin_lock_irqsave(&subs->lock, flags);
369 oldptr = subs->hwptr_done; 369 oldptr = subs->hwptr_done;
370 subs->hwptr_done += len; 370 subs->hwptr_done += len;
371 if (subs->hwptr_done >= runtime->buffer_size) 371 if (subs->hwptr_done >= runtime->buffer_size)
372 subs->hwptr_done -= runtime->buffer_size; 372 subs->hwptr_done -= runtime->buffer_size;
373 subs->transfer_done += len; 373 subs->transfer_done += len;
374 if (subs->transfer_done >= runtime->period_size) { 374 if (subs->transfer_done >= runtime->period_size) {
375 subs->transfer_done -= runtime->period_size; 375 subs->transfer_done -= runtime->period_size;
376 period_elapsed = 1; 376 period_elapsed = 1;
377 } 377 }
378 spin_unlock_irqrestore(&subs->lock, flags); 378 spin_unlock_irqrestore(&subs->lock, flags);
379 /* copy a data chunk */ 379 /* copy a data chunk */
380 if (oldptr + len > runtime->buffer_size) { 380 if (oldptr + len > runtime->buffer_size) {
381 unsigned int cnt = runtime->buffer_size - oldptr; 381 unsigned int cnt = runtime->buffer_size - oldptr;
382 unsigned int blen = cnt * stride; 382 unsigned int blen = cnt * stride;
383 memcpy(runtime->dma_area + oldptr * stride, cp, blen); 383 memcpy(runtime->dma_area + oldptr * stride, cp, blen);
384 memcpy(runtime->dma_area, cp + blen, len * stride - blen); 384 memcpy(runtime->dma_area, cp + blen, len * stride - blen);
385 } else { 385 } else {
386 memcpy(runtime->dma_area + oldptr * stride, cp, len * stride); 386 memcpy(runtime->dma_area + oldptr * stride, cp, len * stride);
387 } 387 }
388 } 388 }
389 if (period_elapsed) 389 if (period_elapsed)
390 snd_pcm_period_elapsed(subs->pcm_substream); 390 snd_pcm_period_elapsed(subs->pcm_substream);
391 return 0; 391 return 0;
392 } 392 }
393 393
394 394
395 /* 395 /*
396 * prepare urb for full speed playback sync pipe 396 * prepare urb for full speed playback sync pipe
397 * 397 *
398 * set up the offset and length to receive the current frequency. 398 * set up the offset and length to receive the current frequency.
399 */ 399 */
400 400
401 static int prepare_playback_sync_urb(struct snd_usb_substream *subs, 401 static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
402 struct snd_pcm_runtime *runtime, 402 struct snd_pcm_runtime *runtime,
403 struct urb *urb) 403 struct urb *urb)
404 { 404 {
405 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 405 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
406 406
407 urb->dev = ctx->subs->dev; /* we need to set this at each time */ 407 urb->dev = ctx->subs->dev; /* we need to set this at each time */
408 urb->iso_frame_desc[0].length = 3; 408 urb->iso_frame_desc[0].length = 3;
409 urb->iso_frame_desc[0].offset = 0; 409 urb->iso_frame_desc[0].offset = 0;
410 return 0; 410 return 0;
411 } 411 }
412 412
413 /* 413 /*
414 * prepare urb for high speed playback sync pipe 414 * prepare urb for high speed playback sync pipe
415 * 415 *
416 * set up the offset and length to receive the current frequency. 416 * set up the offset and length to receive the current frequency.
417 */ 417 */
418 418
419 static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs, 419 static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs,
420 struct snd_pcm_runtime *runtime, 420 struct snd_pcm_runtime *runtime,
421 struct urb *urb) 421 struct urb *urb)
422 { 422 {
423 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 423 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
424 424
425 urb->dev = ctx->subs->dev; /* we need to set this at each time */ 425 urb->dev = ctx->subs->dev; /* we need to set this at each time */
426 urb->iso_frame_desc[0].length = 4; 426 urb->iso_frame_desc[0].length = 4;
427 urb->iso_frame_desc[0].offset = 0; 427 urb->iso_frame_desc[0].offset = 0;
428 return 0; 428 return 0;
429 } 429 }
430 430
431 /* 431 /*
432 * process after full speed playback sync complete 432 * process after full speed playback sync complete
433 * 433 *
434 * retrieve the current 10.14 frequency from pipe, and set it. 434 * retrieve the current 10.14 frequency from pipe, and set it.
435 * the value is referred in prepare_playback_urb(). 435 * the value is referred in prepare_playback_urb().
436 */ 436 */
437 static int retire_playback_sync_urb(struct snd_usb_substream *subs, 437 static int retire_playback_sync_urb(struct snd_usb_substream *subs,
438 struct snd_pcm_runtime *runtime, 438 struct snd_pcm_runtime *runtime,
439 struct urb *urb) 439 struct urb *urb)
440 { 440 {
441 unsigned int f; 441 unsigned int f;
442 unsigned long flags; 442 unsigned long flags;
443 443
444 if (urb->iso_frame_desc[0].status == 0 && 444 if (urb->iso_frame_desc[0].status == 0 &&
445 urb->iso_frame_desc[0].actual_length == 3) { 445 urb->iso_frame_desc[0].actual_length == 3) {
446 f = combine_triple((u8*)urb->transfer_buffer) << 2; 446 f = combine_triple((u8*)urb->transfer_buffer) << 2;
447 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) { 447 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
448 spin_lock_irqsave(&subs->lock, flags); 448 spin_lock_irqsave(&subs->lock, flags);
449 subs->freqm = f; 449 subs->freqm = f;
450 spin_unlock_irqrestore(&subs->lock, flags); 450 spin_unlock_irqrestore(&subs->lock, flags);
451 } 451 }
452 } 452 }
453 453
454 return 0; 454 return 0;
455 } 455 }
456 456
457 /* 457 /*
458 * process after high speed playback sync complete 458 * process after high speed playback sync complete
459 * 459 *
460 * retrieve the current 12.13 frequency from pipe, and set it. 460 * retrieve the current 12.13 frequency from pipe, and set it.
461 * the value is referred in prepare_playback_urb(). 461 * the value is referred in prepare_playback_urb().
462 */ 462 */
463 static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs, 463 static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs,
464 struct snd_pcm_runtime *runtime, 464 struct snd_pcm_runtime *runtime,
465 struct urb *urb) 465 struct urb *urb)
466 { 466 {
467 unsigned int f; 467 unsigned int f;
468 unsigned long flags; 468 unsigned long flags;
469 469
470 if (urb->iso_frame_desc[0].status == 0 && 470 if (urb->iso_frame_desc[0].status == 0 &&
471 urb->iso_frame_desc[0].actual_length == 4) { 471 urb->iso_frame_desc[0].actual_length == 4) {
472 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff; 472 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
473 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) { 473 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
474 spin_lock_irqsave(&subs->lock, flags); 474 spin_lock_irqsave(&subs->lock, flags);
475 subs->freqm = f; 475 subs->freqm = f;
476 spin_unlock_irqrestore(&subs->lock, flags); 476 spin_unlock_irqrestore(&subs->lock, flags);
477 } 477 }
478 } 478 }
479 479
480 return 0; 480 return 0;
481 } 481 }
482 482
483 /* determine the number of frames in the next packet */ 483 /* determine the number of frames in the next packet */
484 static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs) 484 static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs)
485 { 485 {
486 if (subs->fill_max) 486 if (subs->fill_max)
487 return subs->maxframesize; 487 return subs->maxframesize;
488 else { 488 else {
489 subs->phase = (subs->phase & 0xffff) 489 subs->phase = (subs->phase & 0xffff)
490 + (subs->freqm << subs->datainterval); 490 + (subs->freqm << subs->datainterval);
491 return min(subs->phase >> 16, subs->maxframesize); 491 return min(subs->phase >> 16, subs->maxframesize);
492 } 492 }
493 } 493 }
494 494
495 /* 495 /*
496 * Prepare urb for streaming before playback starts. 496 * Prepare urb for streaming before playback starts.
497 * 497 *
498 * We don't yet have data, so we send a frame of silence. 498 * We don't yet have data, so we send a frame of silence.
499 */ 499 */
500 static int prepare_startup_playback_urb(struct snd_usb_substream *subs, 500 static int prepare_startup_playback_urb(struct snd_usb_substream *subs,
501 struct snd_pcm_runtime *runtime, 501 struct snd_pcm_runtime *runtime,
502 struct urb *urb) 502 struct urb *urb)
503 { 503 {
504 unsigned int i, offs, counts; 504 unsigned int i, offs, counts;
505 struct snd_urb_ctx *ctx = urb->context; 505 struct snd_urb_ctx *ctx = urb->context;
506 int stride = runtime->frame_bits >> 3; 506 int stride = runtime->frame_bits >> 3;
507 507
508 offs = 0; 508 offs = 0;
509 urb->dev = ctx->subs->dev; 509 urb->dev = ctx->subs->dev;
510 urb->number_of_packets = subs->packs_per_ms; 510 urb->number_of_packets = subs->packs_per_ms;
511 for (i = 0; i < subs->packs_per_ms; ++i) { 511 for (i = 0; i < subs->packs_per_ms; ++i) {
512 counts = snd_usb_audio_next_packet_size(subs); 512 counts = snd_usb_audio_next_packet_size(subs);
513 urb->iso_frame_desc[i].offset = offs * stride; 513 urb->iso_frame_desc[i].offset = offs * stride;
514 urb->iso_frame_desc[i].length = counts * stride; 514 urb->iso_frame_desc[i].length = counts * stride;
515 offs += counts; 515 offs += counts;
516 } 516 }
517 urb->transfer_buffer_length = offs * stride; 517 urb->transfer_buffer_length = offs * stride;
518 memset(urb->transfer_buffer, 518 memset(urb->transfer_buffer,
519 subs->cur_audiofmt->format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0, 519 subs->cur_audiofmt->format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0,
520 offs * stride); 520 offs * stride);
521 return 0; 521 return 0;
522 } 522 }
523 523
524 /* 524 /*
525 * prepare urb for playback data pipe 525 * prepare urb for playback data pipe
526 * 526 *
527 * Since a URB can handle only a single linear buffer, we must use double 527 * Since a URB can handle only a single linear buffer, we must use double
528 * buffering when the data to be transferred overflows the buffer boundary. 528 * buffering when the data to be transferred overflows the buffer boundary.
529 * To avoid inconsistencies when updating hwptr_done, we use double buffering 529 * To avoid inconsistencies when updating hwptr_done, we use double buffering
530 * for all URBs. 530 * for all URBs.
531 */ 531 */
532 static int prepare_playback_urb(struct snd_usb_substream *subs, 532 static int prepare_playback_urb(struct snd_usb_substream *subs,
533 struct snd_pcm_runtime *runtime, 533 struct snd_pcm_runtime *runtime,
534 struct urb *urb) 534 struct urb *urb)
535 { 535 {
536 int i, stride, offs; 536 int i, stride, offs;
537 unsigned int counts; 537 unsigned int counts;
538 unsigned long flags; 538 unsigned long flags;
539 int period_elapsed = 0; 539 int period_elapsed = 0;
540 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 540 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
541 541
542 stride = runtime->frame_bits >> 3; 542 stride = runtime->frame_bits >> 3;
543 543
544 offs = 0; 544 offs = 0;
545 urb->dev = ctx->subs->dev; /* we need to set this at each time */ 545 urb->dev = ctx->subs->dev; /* we need to set this at each time */
546 urb->number_of_packets = 0; 546 urb->number_of_packets = 0;
547 spin_lock_irqsave(&subs->lock, flags); 547 spin_lock_irqsave(&subs->lock, flags);
548 for (i = 0; i < ctx->packets; i++) { 548 for (i = 0; i < ctx->packets; i++) {
549 counts = snd_usb_audio_next_packet_size(subs); 549 counts = snd_usb_audio_next_packet_size(subs);
550 /* set up descriptor */ 550 /* set up descriptor */
551 urb->iso_frame_desc[i].offset = offs * stride; 551 urb->iso_frame_desc[i].offset = offs * stride;
552 urb->iso_frame_desc[i].length = counts * stride; 552 urb->iso_frame_desc[i].length = counts * stride;
553 offs += counts; 553 offs += counts;
554 urb->number_of_packets++; 554 urb->number_of_packets++;
555 subs->transfer_done += counts; 555 subs->transfer_done += counts;
556 if (subs->transfer_done >= runtime->period_size) { 556 if (subs->transfer_done >= runtime->period_size) {
557 subs->transfer_done -= runtime->period_size; 557 subs->transfer_done -= runtime->period_size;
558 period_elapsed = 1; 558 period_elapsed = 1;
559 if (subs->fmt_type == USB_FORMAT_TYPE_II) { 559 if (subs->fmt_type == USB_FORMAT_TYPE_II) {
560 if (subs->transfer_done > 0) { 560 if (subs->transfer_done > 0) {
561 /* FIXME: fill-max mode is not 561 /* FIXME: fill-max mode is not
562 * supported yet */ 562 * supported yet */
563 offs -= subs->transfer_done; 563 offs -= subs->transfer_done;
564 counts -= subs->transfer_done; 564 counts -= subs->transfer_done;
565 urb->iso_frame_desc[i].length = 565 urb->iso_frame_desc[i].length =
566 counts * stride; 566 counts * stride;
567 subs->transfer_done = 0; 567 subs->transfer_done = 0;
568 } 568 }
569 i++; 569 i++;
570 if (i < ctx->packets) { 570 if (i < ctx->packets) {
571 /* add a transfer delimiter */ 571 /* add a transfer delimiter */
572 urb->iso_frame_desc[i].offset = 572 urb->iso_frame_desc[i].offset =
573 offs * stride; 573 offs * stride;
574 urb->iso_frame_desc[i].length = 0; 574 urb->iso_frame_desc[i].length = 0;
575 urb->number_of_packets++; 575 urb->number_of_packets++;
576 } 576 }
577 break; 577 break;
578 } 578 }
579 } 579 }
580 /* finish at the frame boundary at/after the period boundary */ 580 /* finish at the frame boundary at/after the period boundary */
581 if (period_elapsed && 581 if (period_elapsed &&
582 (i & (subs->packs_per_ms - 1)) == subs->packs_per_ms - 1) 582 (i & (subs->packs_per_ms - 1)) == subs->packs_per_ms - 1)
583 break; 583 break;
584 } 584 }
585 if (subs->hwptr_done + offs > runtime->buffer_size) { 585 if (subs->hwptr_done + offs > runtime->buffer_size) {
586 /* err, the transferred area goes over buffer boundary. */ 586 /* err, the transferred area goes over buffer boundary. */
587 unsigned int len = runtime->buffer_size - subs->hwptr_done; 587 unsigned int len = runtime->buffer_size - subs->hwptr_done;
588 memcpy(urb->transfer_buffer, 588 memcpy(urb->transfer_buffer,
589 runtime->dma_area + subs->hwptr_done * stride, 589 runtime->dma_area + subs->hwptr_done * stride,
590 len * stride); 590 len * stride);
591 memcpy(urb->transfer_buffer + len * stride, 591 memcpy(urb->transfer_buffer + len * stride,
592 runtime->dma_area, 592 runtime->dma_area,
593 (offs - len) * stride); 593 (offs - len) * stride);
594 } else { 594 } else {
595 memcpy(urb->transfer_buffer, 595 memcpy(urb->transfer_buffer,
596 runtime->dma_area + subs->hwptr_done * stride, 596 runtime->dma_area + subs->hwptr_done * stride,
597 offs * stride); 597 offs * stride);
598 } 598 }
599 subs->hwptr_done += offs; 599 subs->hwptr_done += offs;
600 if (subs->hwptr_done >= runtime->buffer_size) 600 if (subs->hwptr_done >= runtime->buffer_size)
601 subs->hwptr_done -= runtime->buffer_size; 601 subs->hwptr_done -= runtime->buffer_size;
602 spin_unlock_irqrestore(&subs->lock, flags); 602 spin_unlock_irqrestore(&subs->lock, flags);
603 urb->transfer_buffer_length = offs * stride; 603 urb->transfer_buffer_length = offs * stride;
604 if (period_elapsed) 604 if (period_elapsed)
605 snd_pcm_period_elapsed(subs->pcm_substream); 605 snd_pcm_period_elapsed(subs->pcm_substream);
606 return 0; 606 return 0;
607 } 607 }
608 608
609 /* 609 /*
610 * process after playback data complete 610 * process after playback data complete
611 * - nothing to do 611 * - nothing to do
612 */ 612 */
613 static int retire_playback_urb(struct snd_usb_substream *subs, 613 static int retire_playback_urb(struct snd_usb_substream *subs,
614 struct snd_pcm_runtime *runtime, 614 struct snd_pcm_runtime *runtime,
615 struct urb *urb) 615 struct urb *urb)
616 { 616 {
617 return 0; 617 return 0;
618 } 618 }
619 619
620 620
621 /* 621 /*
622 */ 622 */
623 static struct snd_urb_ops audio_urb_ops[2] = { 623 static struct snd_urb_ops audio_urb_ops[2] = {
624 { 624 {
625 .prepare = prepare_startup_playback_urb, 625 .prepare = prepare_startup_playback_urb,
626 .retire = retire_playback_urb, 626 .retire = retire_playback_urb,
627 .prepare_sync = prepare_playback_sync_urb, 627 .prepare_sync = prepare_playback_sync_urb,
628 .retire_sync = retire_playback_sync_urb, 628 .retire_sync = retire_playback_sync_urb,
629 }, 629 },
630 { 630 {
631 .prepare = prepare_capture_urb, 631 .prepare = prepare_capture_urb,
632 .retire = retire_capture_urb, 632 .retire = retire_capture_urb,
633 .prepare_sync = prepare_capture_sync_urb, 633 .prepare_sync = prepare_capture_sync_urb,
634 .retire_sync = retire_capture_sync_urb, 634 .retire_sync = retire_capture_sync_urb,
635 }, 635 },
636 }; 636 };
637 637
638 static struct snd_urb_ops audio_urb_ops_high_speed[2] = { 638 static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
639 { 639 {
640 .prepare = prepare_startup_playback_urb, 640 .prepare = prepare_startup_playback_urb,
641 .retire = retire_playback_urb, 641 .retire = retire_playback_urb,
642 .prepare_sync = prepare_playback_sync_urb_hs, 642 .prepare_sync = prepare_playback_sync_urb_hs,
643 .retire_sync = retire_playback_sync_urb_hs, 643 .retire_sync = retire_playback_sync_urb_hs,
644 }, 644 },
645 { 645 {
646 .prepare = prepare_capture_urb, 646 .prepare = prepare_capture_urb,
647 .retire = retire_capture_urb, 647 .retire = retire_capture_urb,
648 .prepare_sync = prepare_capture_sync_urb_hs, 648 .prepare_sync = prepare_capture_sync_urb_hs,
649 .retire_sync = retire_capture_sync_urb, 649 .retire_sync = retire_capture_sync_urb,
650 }, 650 },
651 }; 651 };
652 652
653 /* 653 /*
654 * complete callback from data urb 654 * complete callback from data urb
655 */ 655 */
656 static void snd_complete_urb(struct urb *urb, struct pt_regs *regs) 656 static void snd_complete_urb(struct urb *urb, struct pt_regs *regs)
657 { 657 {
658 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 658 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
659 struct snd_usb_substream *subs = ctx->subs; 659 struct snd_usb_substream *subs = ctx->subs;
660 struct snd_pcm_substream *substream = ctx->subs->pcm_substream; 660 struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
661 int err = 0; 661 int err = 0;
662 662
663 if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) || 663 if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
664 ! subs->running || /* can be stopped during retire callback */ 664 ! subs->running || /* can be stopped during retire callback */
665 (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 || 665 (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
666 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) { 666 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
667 clear_bit(ctx->index, &subs->active_mask); 667 clear_bit(ctx->index, &subs->active_mask);
668 if (err < 0) { 668 if (err < 0) {
669 snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err); 669 snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
670 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); 670 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
671 } 671 }
672 } 672 }
673 } 673 }
674 674
675 675
676 /* 676 /*
677 * complete callback from sync urb 677 * complete callback from sync urb
678 */ 678 */
679 static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs) 679 static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs)
680 { 680 {
681 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; 681 struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context;
682 struct snd_usb_substream *subs = ctx->subs; 682 struct snd_usb_substream *subs = ctx->subs;
683 struct snd_pcm_substream *substream = ctx->subs->pcm_substream; 683 struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
684 int err = 0; 684 int err = 0;
685 685
686 if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) || 686 if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
687 ! subs->running || /* can be stopped during retire callback */ 687 ! subs->running || /* can be stopped during retire callback */
688 (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 || 688 (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
689 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) { 689 (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
690 clear_bit(ctx->index + 16, &subs->active_mask); 690 clear_bit(ctx->index + 16, &subs->active_mask);
691 if (err < 0) { 691 if (err < 0) {
692 snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err); 692 snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
693 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); 693 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
694 } 694 }
695 } 695 }
696 } 696 }
697 697
698 698
699 /* get the physical page pointer at the given offset */ 699 /* get the physical page pointer at the given offset */
700 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, 700 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
701 unsigned long offset) 701 unsigned long offset)
702 { 702 {
703 void *pageptr = subs->runtime->dma_area + offset; 703 void *pageptr = subs->runtime->dma_area + offset;
704 return vmalloc_to_page(pageptr); 704 return vmalloc_to_page(pageptr);
705 } 705 }
706 706
707 /* allocate virtual buffer; may be called more than once */ 707 /* allocate virtual buffer; may be called more than once */
708 static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size) 708 static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
709 { 709 {
710 struct snd_pcm_runtime *runtime = subs->runtime; 710 struct snd_pcm_runtime *runtime = subs->runtime;
711 if (runtime->dma_area) { 711 if (runtime->dma_area) {
712 if (runtime->dma_bytes >= size) 712 if (runtime->dma_bytes >= size)
713 return 0; /* already large enough */ 713 return 0; /* already large enough */
714 vfree(runtime->dma_area); 714 vfree(runtime->dma_area);
715 } 715 }
716 runtime->dma_area = vmalloc(size); 716 runtime->dma_area = vmalloc(size);
717 if (! runtime->dma_area) 717 if (! runtime->dma_area)
718 return -ENOMEM; 718 return -ENOMEM;
719 runtime->dma_bytes = size; 719 runtime->dma_bytes = size;
720 return 0; 720 return 0;
721 } 721 }
722 722
723 /* free virtual buffer; may be called more than once */ 723 /* free virtual buffer; may be called more than once */
724 static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs) 724 static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
725 { 725 {
726 struct snd_pcm_runtime *runtime = subs->runtime; 726 struct snd_pcm_runtime *runtime = subs->runtime;
727 727
728 vfree(runtime->dma_area); 728 vfree(runtime->dma_area);
729 runtime->dma_area = NULL; 729 runtime->dma_area = NULL;
730 return 0; 730 return 0;
731 } 731 }
732 732
733 733
734 /* 734 /*
735 * unlink active urbs. 735 * unlink active urbs.
736 */ 736 */
737 static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep) 737 static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep)
738 { 738 {
739 unsigned int i; 739 unsigned int i;
740 int async; 740 int async;
741 741
742 subs->running = 0; 742 subs->running = 0;
743 743
744 if (!force && subs->stream->chip->shutdown) /* to be sure... */ 744 if (!force && subs->stream->chip->shutdown) /* to be sure... */
745 return -EBADFD; 745 return -EBADFD;
746 746
747 async = !can_sleep && async_unlink; 747 async = !can_sleep && async_unlink;
748 748
749 if (! async && in_interrupt()) 749 if (! async && in_interrupt())
750 return 0; 750 return 0;
751 751
752 for (i = 0; i < subs->nurbs; i++) { 752 for (i = 0; i < subs->nurbs; i++) {
753 if (test_bit(i, &subs->active_mask)) { 753 if (test_bit(i, &subs->active_mask)) {
754 if (! test_and_set_bit(i, &subs->unlink_mask)) { 754 if (! test_and_set_bit(i, &subs->unlink_mask)) {
755 struct urb *u = subs->dataurb[i].urb; 755 struct urb *u = subs->dataurb[i].urb;
756 if (async) 756 if (async)
757 usb_unlink_urb(u); 757 usb_unlink_urb(u);
758 else 758 else
759 usb_kill_urb(u); 759 usb_kill_urb(u);
760 } 760 }
761 } 761 }
762 } 762 }
763 if (subs->syncpipe) { 763 if (subs->syncpipe) {
764 for (i = 0; i < SYNC_URBS; i++) { 764 for (i = 0; i < SYNC_URBS; i++) {
765 if (test_bit(i+16, &subs->active_mask)) { 765 if (test_bit(i+16, &subs->active_mask)) {
766 if (! test_and_set_bit(i+16, &subs->unlink_mask)) { 766 if (! test_and_set_bit(i+16, &subs->unlink_mask)) {
767 struct urb *u = subs->syncurb[i].urb; 767 struct urb *u = subs->syncurb[i].urb;
768 if (async) 768 if (async)
769 usb_unlink_urb(u); 769 usb_unlink_urb(u);
770 else 770 else
771 usb_kill_urb(u); 771 usb_kill_urb(u);
772 } 772 }
773 } 773 }
774 } 774 }
775 } 775 }
776 return 0; 776 return 0;
777 } 777 }
778 778
779 779
780 static const char *usb_error_string(int err) 780 static const char *usb_error_string(int err)
781 { 781 {
782 switch (err) { 782 switch (err) {
783 case -ENODEV: 783 case -ENODEV:
784 return "no device"; 784 return "no device";
785 case -ENOENT: 785 case -ENOENT:
786 return "endpoint not enabled"; 786 return "endpoint not enabled";
787 case -EPIPE: 787 case -EPIPE:
788 return "endpoint stalled"; 788 return "endpoint stalled";
789 case -ENOSPC: 789 case -ENOSPC:
790 return "not enough bandwidth"; 790 return "not enough bandwidth";
791 case -ESHUTDOWN: 791 case -ESHUTDOWN:
792 return "device disabled"; 792 return "device disabled";
793 case -EHOSTUNREACH: 793 case -EHOSTUNREACH:
794 return "device suspended"; 794 return "device suspended";
795 #ifndef CONFIG_USB_EHCI_SPLIT_ISO 795 #ifndef CONFIG_USB_EHCI_SPLIT_ISO
796 case -ENOSYS: 796 case -ENOSYS:
797 return "enable CONFIG_USB_EHCI_SPLIT_ISO to play through a hub"; 797 return "enable CONFIG_USB_EHCI_SPLIT_ISO to play through a hub";
798 #endif 798 #endif
799 case -EINVAL: 799 case -EINVAL:
800 case -EAGAIN: 800 case -EAGAIN:
801 case -EFBIG: 801 case -EFBIG:
802 case -EMSGSIZE: 802 case -EMSGSIZE:
803 return "internal error"; 803 return "internal error";
804 default: 804 default:
805 return "unknown error"; 805 return "unknown error";
806 } 806 }
807 } 807 }
808 808
809 /* 809 /*
810 * set up and start data/sync urbs 810 * set up and start data/sync urbs
811 */ 811 */
812 static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime) 812 static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime)
813 { 813 {
814 unsigned int i; 814 unsigned int i;
815 int err; 815 int err;
816 816
817 if (subs->stream->chip->shutdown) 817 if (subs->stream->chip->shutdown)
818 return -EBADFD; 818 return -EBADFD;
819 819
820 for (i = 0; i < subs->nurbs; i++) { 820 for (i = 0; i < subs->nurbs; i++) {
821 snd_assert(subs->dataurb[i].urb, return -EINVAL); 821 snd_assert(subs->dataurb[i].urb, return -EINVAL);
822 if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) { 822 if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
823 snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i); 823 snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
824 goto __error; 824 goto __error;
825 } 825 }
826 } 826 }
827 if (subs->syncpipe) { 827 if (subs->syncpipe) {
828 for (i = 0; i < SYNC_URBS; i++) { 828 for (i = 0; i < SYNC_URBS; i++) {
829 snd_assert(subs->syncurb[i].urb, return -EINVAL); 829 snd_assert(subs->syncurb[i].urb, return -EINVAL);
830 if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) { 830 if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
831 snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i); 831 snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
832 goto __error; 832 goto __error;
833 } 833 }
834 } 834 }
835 } 835 }
836 836
837 subs->active_mask = 0; 837 subs->active_mask = 0;
838 subs->unlink_mask = 0; 838 subs->unlink_mask = 0;
839 subs->running = 1; 839 subs->running = 1;
840 for (i = 0; i < subs->nurbs; i++) { 840 for (i = 0; i < subs->nurbs; i++) {
841 err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC); 841 err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC);
842 if (err < 0) { 842 if (err < 0) {
843 snd_printk(KERN_ERR "cannot submit datapipe " 843 snd_printk(KERN_ERR "cannot submit datapipe "
844 "for urb %d, error %d: %s\n", 844 "for urb %d, error %d: %s\n",
845 i, err, usb_error_string(err)); 845 i, err, usb_error_string(err));
846 goto __error; 846 goto __error;
847 } 847 }
848 set_bit(i, &subs->active_mask); 848 set_bit(i, &subs->active_mask);
849 } 849 }
850 if (subs->syncpipe) { 850 if (subs->syncpipe) {
851 for (i = 0; i < SYNC_URBS; i++) { 851 for (i = 0; i < SYNC_URBS; i++) {
852 err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC); 852 err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC);
853 if (err < 0) { 853 if (err < 0) {
854 snd_printk(KERN_ERR "cannot submit syncpipe " 854 snd_printk(KERN_ERR "cannot submit syncpipe "
855 "for urb %d, error %d: %s\n", 855 "for urb %d, error %d: %s\n",
856 i, err, usb_error_string(err)); 856 i, err, usb_error_string(err));
857 goto __error; 857 goto __error;
858 } 858 }
859 set_bit(i + 16, &subs->active_mask); 859 set_bit(i + 16, &subs->active_mask);
860 } 860 }
861 } 861 }
862 return 0; 862 return 0;
863 863
864 __error: 864 __error:
865 // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN); 865 // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
866 deactivate_urbs(subs, 0, 0); 866 deactivate_urbs(subs, 0, 0);
867 return -EPIPE; 867 return -EPIPE;
868 } 868 }
869 869
870 870
871 /* 871 /*
872 * wait until all urbs are processed. 872 * wait until all urbs are processed.
873 */ 873 */
874 static int wait_clear_urbs(struct snd_usb_substream *subs) 874 static int wait_clear_urbs(struct snd_usb_substream *subs)
875 { 875 {
876 unsigned long end_time = jiffies + msecs_to_jiffies(1000); 876 unsigned long end_time = jiffies + msecs_to_jiffies(1000);
877 unsigned int i; 877 unsigned int i;
878 int alive; 878 int alive;
879 879
880 do { 880 do {
881 alive = 0; 881 alive = 0;
882 for (i = 0; i < subs->nurbs; i++) { 882 for (i = 0; i < subs->nurbs; i++) {
883 if (test_bit(i, &subs->active_mask)) 883 if (test_bit(i, &subs->active_mask))
884 alive++; 884 alive++;
885 } 885 }
886 if (subs->syncpipe) { 886 if (subs->syncpipe) {
887 for (i = 0; i < SYNC_URBS; i++) { 887 for (i = 0; i < SYNC_URBS; i++) {
888 if (test_bit(i + 16, &subs->active_mask)) 888 if (test_bit(i + 16, &subs->active_mask))
889 alive++; 889 alive++;
890 } 890 }
891 } 891 }
892 if (! alive) 892 if (! alive)
893 break; 893 break;
894 schedule_timeout_uninterruptible(1); 894 schedule_timeout_uninterruptible(1);
895 } while (time_before(jiffies, end_time)); 895 } while (time_before(jiffies, end_time));
896 if (alive) 896 if (alive)
897 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive); 897 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
898 return 0; 898 return 0;
899 } 899 }
900 900
901 901
902 /* 902 /*
903 * return the current pcm pointer. just return the hwptr_done value. 903 * return the current pcm pointer. just return the hwptr_done value.
904 */ 904 */
905 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream) 905 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
906 { 906 {
907 struct snd_usb_substream *subs; 907 struct snd_usb_substream *subs;
908 snd_pcm_uframes_t hwptr_done; 908 snd_pcm_uframes_t hwptr_done;
909 909
910 subs = (struct snd_usb_substream *)substream->runtime->private_data; 910 subs = (struct snd_usb_substream *)substream->runtime->private_data;
911 spin_lock(&subs->lock); 911 spin_lock(&subs->lock);
912 hwptr_done = subs->hwptr_done; 912 hwptr_done = subs->hwptr_done;
913 spin_unlock(&subs->lock); 913 spin_unlock(&subs->lock);
914 return hwptr_done; 914 return hwptr_done;
915 } 915 }
916 916
917 917
918 /* 918 /*
919 * start/stop playback substream 919 * start/stop playback substream
920 */ 920 */
921 static int snd_usb_pcm_playback_trigger(struct snd_pcm_substream *substream, 921 static int snd_usb_pcm_playback_trigger(struct snd_pcm_substream *substream,
922 int cmd) 922 int cmd)
923 { 923 {
924 struct snd_usb_substream *subs = substream->runtime->private_data; 924 struct snd_usb_substream *subs = substream->runtime->private_data;
925 925
926 switch (cmd) { 926 switch (cmd) {
927 case SNDRV_PCM_TRIGGER_START: 927 case SNDRV_PCM_TRIGGER_START:
928 subs->ops.prepare = prepare_playback_urb; 928 subs->ops.prepare = prepare_playback_urb;
929 return 0; 929 return 0;
930 case SNDRV_PCM_TRIGGER_STOP: 930 case SNDRV_PCM_TRIGGER_STOP:
931 return deactivate_urbs(subs, 0, 0); 931 return deactivate_urbs(subs, 0, 0);
932 default: 932 default:
933 return -EINVAL; 933 return -EINVAL;
934 } 934 }
935 } 935 }
936 936
937 /* 937 /*
938 * start/stop capture substream 938 * start/stop capture substream
939 */ 939 */
940 static int snd_usb_pcm_capture_trigger(struct snd_pcm_substream *substream, 940 static int snd_usb_pcm_capture_trigger(struct snd_pcm_substream *substream,
941 int cmd) 941 int cmd)
942 { 942 {
943 struct snd_usb_substream *subs = substream->runtime->private_data; 943 struct snd_usb_substream *subs = substream->runtime->private_data;
944 944
945 switch (cmd) { 945 switch (cmd) {
946 case SNDRV_PCM_TRIGGER_START: 946 case SNDRV_PCM_TRIGGER_START:
947 return start_urbs(subs, substream->runtime); 947 return start_urbs(subs, substream->runtime);
948 case SNDRV_PCM_TRIGGER_STOP: 948 case SNDRV_PCM_TRIGGER_STOP:
949 return deactivate_urbs(subs, 0, 0); 949 return deactivate_urbs(subs, 0, 0);
950 default: 950 default:
951 return -EINVAL; 951 return -EINVAL;
952 } 952 }
953 } 953 }
954 954
955 955
956 /* 956 /*
957 * release a urb data 957 * release a urb data
958 */ 958 */
959 static void release_urb_ctx(struct snd_urb_ctx *u) 959 static void release_urb_ctx(struct snd_urb_ctx *u)
960 { 960 {
961 if (u->urb) { 961 if (u->urb) {
962 if (u->buffer_size) 962 if (u->buffer_size)
963 usb_buffer_free(u->subs->dev, u->buffer_size, 963 usb_buffer_free(u->subs->dev, u->buffer_size,
964 u->urb->transfer_buffer, 964 u->urb->transfer_buffer,
965 u->urb->transfer_dma); 965 u->urb->transfer_dma);
966 usb_free_urb(u->urb); 966 usb_free_urb(u->urb);
967 u->urb = NULL; 967 u->urb = NULL;
968 } 968 }
969 } 969 }
970 970
971 /* 971 /*
972 * release a substream 972 * release a substream
973 */ 973 */
974 static void release_substream_urbs(struct snd_usb_substream *subs, int force) 974 static void release_substream_urbs(struct snd_usb_substream *subs, int force)
975 { 975 {
976 int i; 976 int i;
977 977
978 /* stop urbs (to be sure) */ 978 /* stop urbs (to be sure) */
979 deactivate_urbs(subs, force, 1); 979 deactivate_urbs(subs, force, 1);
980 wait_clear_urbs(subs); 980 wait_clear_urbs(subs);
981 981
982 for (i = 0; i < MAX_URBS; i++) 982 for (i = 0; i < MAX_URBS; i++)
983 release_urb_ctx(&subs->dataurb[i]); 983 release_urb_ctx(&subs->dataurb[i]);
984 for (i = 0; i < SYNC_URBS; i++) 984 for (i = 0; i < SYNC_URBS; i++)
985 release_urb_ctx(&subs->syncurb[i]); 985 release_urb_ctx(&subs->syncurb[i]);
986 usb_buffer_free(subs->dev, SYNC_URBS * 4, 986 usb_buffer_free(subs->dev, SYNC_URBS * 4,
987 subs->syncbuf, subs->sync_dma); 987 subs->syncbuf, subs->sync_dma);
988 subs->syncbuf = NULL; 988 subs->syncbuf = NULL;
989 subs->nurbs = 0; 989 subs->nurbs = 0;
990 } 990 }
991 991
992 /* 992 /*
993 * initialize a substream for plaback/capture 993 * initialize a substream for plaback/capture
994 */ 994 */
995 static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int period_bytes, 995 static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int period_bytes,
996 unsigned int rate, unsigned int frame_bits) 996 unsigned int rate, unsigned int frame_bits)
997 { 997 {
998 unsigned int maxsize, n, i; 998 unsigned int maxsize, n, i;
999 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK; 999 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1000 unsigned int npacks[MAX_URBS], urb_packs, total_packs, packs_per_ms; 1000 unsigned int npacks[MAX_URBS], urb_packs, total_packs, packs_per_ms;
1001 1001
1002 /* calculate the frequency in 16.16 format */ 1002 /* calculate the frequency in 16.16 format */
1003 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) 1003 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1004 subs->freqn = get_usb_full_speed_rate(rate); 1004 subs->freqn = get_usb_full_speed_rate(rate);
1005 else 1005 else
1006 subs->freqn = get_usb_high_speed_rate(rate); 1006 subs->freqn = get_usb_high_speed_rate(rate);
1007 subs->freqm = subs->freqn; 1007 subs->freqm = subs->freqn;
1008 /* calculate max. frequency */ 1008 /* calculate max. frequency */
1009 if (subs->maxpacksize) { 1009 if (subs->maxpacksize) {
1010 /* whatever fits into a max. size packet */ 1010 /* whatever fits into a max. size packet */
1011 maxsize = subs->maxpacksize; 1011 maxsize = subs->maxpacksize;
1012 subs->freqmax = (maxsize / (frame_bits >> 3)) 1012 subs->freqmax = (maxsize / (frame_bits >> 3))
1013 << (16 - subs->datainterval); 1013 << (16 - subs->datainterval);
1014 } else { 1014 } else {
1015 /* no max. packet size: just take 25% higher than nominal */ 1015 /* no max. packet size: just take 25% higher than nominal */
1016 subs->freqmax = subs->freqn + (subs->freqn >> 2); 1016 subs->freqmax = subs->freqn + (subs->freqn >> 2);
1017 maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3)) 1017 maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3))
1018 >> (16 - subs->datainterval); 1018 >> (16 - subs->datainterval);
1019 } 1019 }
1020 subs->phase = 0; 1020 subs->phase = 0;
1021 1021
1022 if (subs->fill_max) 1022 if (subs->fill_max)
1023 subs->curpacksize = subs->maxpacksize; 1023 subs->curpacksize = subs->maxpacksize;
1024 else 1024 else
1025 subs->curpacksize = maxsize; 1025 subs->curpacksize = maxsize;
1026 1026
1027 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) 1027 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
1028 packs_per_ms = 8 >> subs->datainterval; 1028 packs_per_ms = 8 >> subs->datainterval;
1029 else 1029 else
1030 packs_per_ms = 1; 1030 packs_per_ms = 1;
1031 subs->packs_per_ms = packs_per_ms; 1031 subs->packs_per_ms = packs_per_ms;
1032 1032
1033 if (is_playback) { 1033 if (is_playback) {
1034 urb_packs = nrpacks; 1034 urb_packs = nrpacks;
1035 urb_packs = max(urb_packs, (unsigned int)MIN_PACKS_URB); 1035 urb_packs = max(urb_packs, (unsigned int)MIN_PACKS_URB);
1036 urb_packs = min(urb_packs, (unsigned int)MAX_PACKS); 1036 urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
1037 } else 1037 } else
1038 urb_packs = 1; 1038 urb_packs = 1;
1039 urb_packs *= packs_per_ms; 1039 urb_packs *= packs_per_ms;
1040 1040
1041 /* decide how many packets to be used */ 1041 /* decide how many packets to be used */
1042 if (is_playback) { 1042 if (is_playback) {
1043 unsigned int minsize; 1043 unsigned int minsize;
1044 /* determine how small a packet can be */ 1044 /* determine how small a packet can be */
1045 minsize = (subs->freqn >> (16 - subs->datainterval)) 1045 minsize = (subs->freqn >> (16 - subs->datainterval))
1046 * (frame_bits >> 3); 1046 * (frame_bits >> 3);
1047 /* with sync from device, assume it can be 12% lower */ 1047 /* with sync from device, assume it can be 12% lower */
1048 if (subs->syncpipe) 1048 if (subs->syncpipe)
1049 minsize -= minsize >> 3; 1049 minsize -= minsize >> 3;
1050 minsize = max(minsize, 1u); 1050 minsize = max(minsize, 1u);
1051 total_packs = (period_bytes + minsize - 1) / minsize; 1051 total_packs = (period_bytes + minsize - 1) / minsize;
1052 /* round up to multiple of packs_per_ms */ 1052 /* round up to multiple of packs_per_ms */
1053 total_packs = (total_packs + packs_per_ms - 1) 1053 total_packs = (total_packs + packs_per_ms - 1)
1054 & ~(packs_per_ms - 1); 1054 & ~(packs_per_ms - 1);
1055 /* we need at least two URBs for queueing */ 1055 /* we need at least two URBs for queueing */
1056 if (total_packs < 2 * MIN_PACKS_URB * packs_per_ms) 1056 if (total_packs < 2 * MIN_PACKS_URB * packs_per_ms)
1057 total_packs = 2 * MIN_PACKS_URB * packs_per_ms; 1057 total_packs = 2 * MIN_PACKS_URB * packs_per_ms;
1058 } else { 1058 } else {
1059 total_packs = MAX_URBS * urb_packs; 1059 total_packs = MAX_URBS * urb_packs;
1060 } 1060 }
1061 subs->nurbs = (total_packs + urb_packs - 1) / urb_packs; 1061 subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
1062 if (subs->nurbs > MAX_URBS) { 1062 if (subs->nurbs > MAX_URBS) {
1063 /* too much... */ 1063 /* too much... */
1064 subs->nurbs = MAX_URBS; 1064 subs->nurbs = MAX_URBS;
1065 total_packs = MAX_URBS * urb_packs; 1065 total_packs = MAX_URBS * urb_packs;
1066 } 1066 }
1067 n = total_packs; 1067 n = total_packs;
1068 for (i = 0; i < subs->nurbs; i++) { 1068 for (i = 0; i < subs->nurbs; i++) {
1069 npacks[i] = n > urb_packs ? urb_packs : n; 1069 npacks[i] = n > urb_packs ? urb_packs : n;
1070 n -= urb_packs; 1070 n -= urb_packs;
1071 } 1071 }
1072 if (subs->nurbs <= 1) { 1072 if (subs->nurbs <= 1) {
1073 /* too little - we need at least two packets 1073 /* too little - we need at least two packets
1074 * to ensure contiguous playback/capture 1074 * to ensure contiguous playback/capture
1075 */ 1075 */
1076 subs->nurbs = 2; 1076 subs->nurbs = 2;
1077 npacks[0] = (total_packs + 1) / 2; 1077 npacks[0] = (total_packs + 1) / 2;
1078 npacks[1] = total_packs - npacks[0]; 1078 npacks[1] = total_packs - npacks[0];
1079 } else if (npacks[subs->nurbs-1] < MIN_PACKS_URB * packs_per_ms) { 1079 } else if (npacks[subs->nurbs-1] < MIN_PACKS_URB * packs_per_ms) {
1080 /* the last packet is too small.. */ 1080 /* the last packet is too small.. */
1081 if (subs->nurbs > 2) { 1081 if (subs->nurbs > 2) {
1082 /* merge to the first one */ 1082 /* merge to the first one */
1083 npacks[0] += npacks[subs->nurbs - 1]; 1083 npacks[0] += npacks[subs->nurbs - 1];
1084 subs->nurbs--; 1084 subs->nurbs--;
1085 } else { 1085 } else {
1086 /* divide to two */ 1086 /* divide to two */
1087 subs->nurbs = 2; 1087 subs->nurbs = 2;
1088 npacks[0] = (total_packs + 1) / 2; 1088 npacks[0] = (total_packs + 1) / 2;
1089 npacks[1] = total_packs - npacks[0]; 1089 npacks[1] = total_packs - npacks[0];
1090 } 1090 }
1091 } 1091 }
1092 1092
1093 /* allocate and initialize data urbs */ 1093 /* allocate and initialize data urbs */
1094 for (i = 0; i < subs->nurbs; i++) { 1094 for (i = 0; i < subs->nurbs; i++) {
1095 struct snd_urb_ctx *u = &subs->dataurb[i]; 1095 struct snd_urb_ctx *u = &subs->dataurb[i];
1096 u->index = i; 1096 u->index = i;
1097 u->subs = subs; 1097 u->subs = subs;
1098 u->packets = npacks[i]; 1098 u->packets = npacks[i];
1099 u->buffer_size = maxsize * u->packets; 1099 u->buffer_size = maxsize * u->packets;
1100 if (subs->fmt_type == USB_FORMAT_TYPE_II) 1100 if (subs->fmt_type == USB_FORMAT_TYPE_II)
1101 u->packets++; /* for transfer delimiter */ 1101 u->packets++; /* for transfer delimiter */
1102 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL); 1102 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
1103 if (! u->urb) 1103 if (! u->urb)
1104 goto out_of_memory; 1104 goto out_of_memory;
1105 u->urb->transfer_buffer = 1105 u->urb->transfer_buffer =
1106 usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL, 1106 usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL,
1107 &u->urb->transfer_dma); 1107 &u->urb->transfer_dma);
1108 if (! u->urb->transfer_buffer) 1108 if (! u->urb->transfer_buffer)
1109 goto out_of_memory; 1109 goto out_of_memory;
1110 u->urb->pipe = subs->datapipe; 1110 u->urb->pipe = subs->datapipe;
1111 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 1111 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1112 u->urb->interval = 1 << subs->datainterval; 1112 u->urb->interval = 1 << subs->datainterval;
1113 u->urb->context = u; 1113 u->urb->context = u;
1114 u->urb->complete = snd_complete_urb; 1114 u->urb->complete = snd_complete_urb;
1115 } 1115 }
1116 1116
1117 if (subs->syncpipe) { 1117 if (subs->syncpipe) {
1118 /* allocate and initialize sync urbs */ 1118 /* allocate and initialize sync urbs */
1119 subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4, 1119 subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4,
1120 GFP_KERNEL, &subs->sync_dma); 1120 GFP_KERNEL, &subs->sync_dma);
1121 if (! subs->syncbuf) 1121 if (! subs->syncbuf)
1122 goto out_of_memory; 1122 goto out_of_memory;
1123 for (i = 0; i < SYNC_URBS; i++) { 1123 for (i = 0; i < SYNC_URBS; i++) {
1124 struct snd_urb_ctx *u = &subs->syncurb[i]; 1124 struct snd_urb_ctx *u = &subs->syncurb[i];
1125 u->index = i; 1125 u->index = i;
1126 u->subs = subs; 1126 u->subs = subs;
1127 u->packets = 1; 1127 u->packets = 1;
1128 u->urb = usb_alloc_urb(1, GFP_KERNEL); 1128 u->urb = usb_alloc_urb(1, GFP_KERNEL);
1129 if (! u->urb) 1129 if (! u->urb)
1130 goto out_of_memory; 1130 goto out_of_memory;
1131 u->urb->transfer_buffer = subs->syncbuf + i * 4; 1131 u->urb->transfer_buffer = subs->syncbuf + i * 4;
1132 u->urb->transfer_dma = subs->sync_dma + i * 4; 1132 u->urb->transfer_dma = subs->sync_dma + i * 4;
1133 u->urb->transfer_buffer_length = 4; 1133 u->urb->transfer_buffer_length = 4;
1134 u->urb->pipe = subs->syncpipe; 1134 u->urb->pipe = subs->syncpipe;
1135 u->urb->transfer_flags = URB_ISO_ASAP | 1135 u->urb->transfer_flags = URB_ISO_ASAP |
1136 URB_NO_TRANSFER_DMA_MAP; 1136 URB_NO_TRANSFER_DMA_MAP;
1137 u->urb->number_of_packets = 1; 1137 u->urb->number_of_packets = 1;
1138 u->urb->interval = 1 << subs->syncinterval; 1138 u->urb->interval = 1 << subs->syncinterval;
1139 u->urb->context = u; 1139 u->urb->context = u;
1140 u->urb->complete = snd_complete_sync_urb; 1140 u->urb->complete = snd_complete_sync_urb;
1141 } 1141 }
1142 } 1142 }
1143 return 0; 1143 return 0;
1144 1144
1145 out_of_memory: 1145 out_of_memory:
1146 release_substream_urbs(subs, 0); 1146 release_substream_urbs(subs, 0);
1147 return -ENOMEM; 1147 return -ENOMEM;
1148 } 1148 }
1149 1149
1150 1150
1151 /* 1151 /*
1152 * find a matching audio format 1152 * find a matching audio format
1153 */ 1153 */
1154 static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format, 1154 static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format,
1155 unsigned int rate, unsigned int channels) 1155 unsigned int rate, unsigned int channels)
1156 { 1156 {
1157 struct list_head *p; 1157 struct list_head *p;
1158 struct audioformat *found = NULL; 1158 struct audioformat *found = NULL;
1159 int cur_attr = 0, attr; 1159 int cur_attr = 0, attr;
1160 1160
1161 list_for_each(p, &subs->fmt_list) { 1161 list_for_each(p, &subs->fmt_list) {
1162 struct audioformat *fp; 1162 struct audioformat *fp;
1163 fp = list_entry(p, struct audioformat, list); 1163 fp = list_entry(p, struct audioformat, list);
1164 if (fp->format != format || fp->channels != channels) 1164 if (fp->format != format || fp->channels != channels)
1165 continue; 1165 continue;
1166 if (rate < fp->rate_min || rate > fp->rate_max) 1166 if (rate < fp->rate_min || rate > fp->rate_max)
1167 continue; 1167 continue;
1168 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) { 1168 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
1169 unsigned int i; 1169 unsigned int i;
1170 for (i = 0; i < fp->nr_rates; i++) 1170 for (i = 0; i < fp->nr_rates; i++)
1171 if (fp->rate_table[i] == rate) 1171 if (fp->rate_table[i] == rate)
1172 break; 1172 break;
1173 if (i >= fp->nr_rates) 1173 if (i >= fp->nr_rates)
1174 continue; 1174 continue;
1175 } 1175 }
1176 attr = fp->ep_attr & EP_ATTR_MASK; 1176 attr = fp->ep_attr & EP_ATTR_MASK;
1177 if (! found) { 1177 if (! found) {
1178 found = fp; 1178 found = fp;
1179 cur_attr = attr; 1179 cur_attr = attr;
1180 continue; 1180 continue;
1181 } 1181 }
1182 /* avoid async out and adaptive in if the other method 1182 /* avoid async out and adaptive in if the other method
1183 * supports the same format. 1183 * supports the same format.
1184 * this is a workaround for the case like 1184 * this is a workaround for the case like
1185 * M-audio audiophile USB. 1185 * M-audio audiophile USB.
1186 */ 1186 */
1187 if (attr != cur_attr) { 1187 if (attr != cur_attr) {
1188 if ((attr == EP_ATTR_ASYNC && 1188 if ((attr == EP_ATTR_ASYNC &&
1189 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || 1189 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1190 (attr == EP_ATTR_ADAPTIVE && 1190 (attr == EP_ATTR_ADAPTIVE &&
1191 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) 1191 subs->direction == SNDRV_PCM_STREAM_CAPTURE))
1192 continue; 1192 continue;
1193 if ((cur_attr == EP_ATTR_ASYNC && 1193 if ((cur_attr == EP_ATTR_ASYNC &&
1194 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || 1194 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1195 (cur_attr == EP_ATTR_ADAPTIVE && 1195 (cur_attr == EP_ATTR_ADAPTIVE &&
1196 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) { 1196 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
1197 found = fp; 1197 found = fp;
1198 cur_attr = attr; 1198 cur_attr = attr;
1199 continue; 1199 continue;
1200 } 1200 }
1201 } 1201 }
1202 /* find the format with the largest max. packet size */ 1202 /* find the format with the largest max. packet size */
1203 if (fp->maxpacksize > found->maxpacksize) { 1203 if (fp->maxpacksize > found->maxpacksize) {
1204 found = fp; 1204 found = fp;
1205 cur_attr = attr; 1205 cur_attr = attr;
1206 } 1206 }
1207 } 1207 }
1208 return found; 1208 return found;
1209 } 1209 }
1210 1210
1211 1211
1212 /* 1212 /*
1213 * initialize the picth control and sample rate 1213 * initialize the picth control and sample rate
1214 */ 1214 */
1215 static int init_usb_pitch(struct usb_device *dev, int iface, 1215 static int init_usb_pitch(struct usb_device *dev, int iface,
1216 struct usb_host_interface *alts, 1216 struct usb_host_interface *alts,
1217 struct audioformat *fmt) 1217 struct audioformat *fmt)
1218 { 1218 {
1219 unsigned int ep; 1219 unsigned int ep;
1220 unsigned char data[1]; 1220 unsigned char data[1];
1221 int err; 1221 int err;
1222 1222
1223 ep = get_endpoint(alts, 0)->bEndpointAddress; 1223 ep = get_endpoint(alts, 0)->bEndpointAddress;
1224 /* if endpoint has pitch control, enable it */ 1224 /* if endpoint has pitch control, enable it */
1225 if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) { 1225 if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
1226 data[0] = 1; 1226 data[0] = 1;
1227 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, 1227 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1228 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT, 1228 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1229 PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) { 1229 PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
1230 snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n", 1230 snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
1231 dev->devnum, iface, ep); 1231 dev->devnum, iface, ep);
1232 return err; 1232 return err;
1233 } 1233 }
1234 } 1234 }
1235 return 0; 1235 return 0;
1236 } 1236 }
1237 1237
1238 static int init_usb_sample_rate(struct usb_device *dev, int iface, 1238 static int init_usb_sample_rate(struct usb_device *dev, int iface,
1239 struct usb_host_interface *alts, 1239 struct usb_host_interface *alts,
1240 struct audioformat *fmt, int rate) 1240 struct audioformat *fmt, int rate)
1241 { 1241 {
1242 unsigned int ep; 1242 unsigned int ep;
1243 unsigned char data[3]; 1243 unsigned char data[3];
1244 int err; 1244 int err;
1245 1245
1246 ep = get_endpoint(alts, 0)->bEndpointAddress; 1246 ep = get_endpoint(alts, 0)->bEndpointAddress;
1247 /* if endpoint has sampling rate control, set it */ 1247 /* if endpoint has sampling rate control, set it */
1248 if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) { 1248 if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
1249 int crate; 1249 int crate;
1250 data[0] = rate; 1250 data[0] = rate;
1251 data[1] = rate >> 8; 1251 data[1] = rate >> 8;
1252 data[2] = rate >> 16; 1252 data[2] = rate >> 16;
1253 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, 1253 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1254 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT, 1254 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1255 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) { 1255 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1256 snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n", 1256 snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n",
1257 dev->devnum, iface, fmt->altsetting, rate, ep); 1257 dev->devnum, iface, fmt->altsetting, rate, ep);
1258 return err; 1258 return err;
1259 } 1259 }
1260 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, 1260 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
1261 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN, 1261 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1262 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) { 1262 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1263 snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep 0x%x\n", 1263 snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep 0x%x\n",
1264 dev->devnum, iface, fmt->altsetting, ep); 1264 dev->devnum, iface, fmt->altsetting, ep);
1265 return 0; /* some devices don't support reading */ 1265 return 0; /* some devices don't support reading */
1266 } 1266 }
1267 crate = data[0] | (data[1] << 8) | (data[2] << 16); 1267 crate = data[0] | (data[1] << 8) | (data[2] << 16);
1268 if (crate != rate) { 1268 if (crate != rate) {
1269 snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate); 1269 snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
1270 // runtime->rate = crate; 1270 // runtime->rate = crate;
1271 } 1271 }
1272 } 1272 }
1273 return 0; 1273 return 0;
1274 } 1274 }
1275 1275
1276 /* 1276 /*
1277 * find a matching format and set up the interface 1277 * find a matching format and set up the interface
1278 */ 1278 */
1279 static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) 1279 static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
1280 { 1280 {
1281 struct usb_device *dev = subs->dev; 1281 struct usb_device *dev = subs->dev;
1282 struct usb_host_interface *alts; 1282 struct usb_host_interface *alts;
1283 struct usb_interface_descriptor *altsd; 1283 struct usb_interface_descriptor *altsd;
1284 struct usb_interface *iface; 1284 struct usb_interface *iface;
1285 unsigned int ep, attr; 1285 unsigned int ep, attr;
1286 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK; 1286 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1287 int err; 1287 int err;
1288 1288
1289 iface = usb_ifnum_to_if(dev, fmt->iface); 1289 iface = usb_ifnum_to_if(dev, fmt->iface);
1290 snd_assert(iface, return -EINVAL); 1290 snd_assert(iface, return -EINVAL);
1291 alts = &iface->altsetting[fmt->altset_idx]; 1291 alts = &iface->altsetting[fmt->altset_idx];
1292 altsd = get_iface_desc(alts); 1292 altsd = get_iface_desc(alts);
1293 snd_assert(altsd->bAlternateSetting == fmt->altsetting, return -EINVAL); 1293 snd_assert(altsd->bAlternateSetting == fmt->altsetting, return -EINVAL);
1294 1294
1295 if (fmt == subs->cur_audiofmt) 1295 if (fmt == subs->cur_audiofmt)
1296 return 0; 1296 return 0;
1297 1297
1298 /* close the old interface */ 1298 /* close the old interface */
1299 if (subs->interface >= 0 && subs->interface != fmt->iface) { 1299 if (subs->interface >= 0 && subs->interface != fmt->iface) {
1300 usb_set_interface(subs->dev, subs->interface, 0); 1300 usb_set_interface(subs->dev, subs->interface, 0);
1301 subs->interface = -1; 1301 subs->interface = -1;
1302 subs->format = 0; 1302 subs->format = 0;
1303 } 1303 }
1304 1304
1305 /* set interface */ 1305 /* set interface */
1306 if (subs->interface != fmt->iface || subs->format != fmt->altset_idx) { 1306 if (subs->interface != fmt->iface || subs->format != fmt->altset_idx) {
1307 if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) { 1307 if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
1308 snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n", 1308 snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
1309 dev->devnum, fmt->iface, fmt->altsetting); 1309 dev->devnum, fmt->iface, fmt->altsetting);
1310 return -EIO; 1310 return -EIO;
1311 } 1311 }
1312 snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting); 1312 snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
1313 subs->interface = fmt->iface; 1313 subs->interface = fmt->iface;
1314 subs->format = fmt->altset_idx; 1314 subs->format = fmt->altset_idx;
1315 } 1315 }
1316 1316
1317 /* create a data pipe */ 1317 /* create a data pipe */
1318 ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK; 1318 ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
1319 if (is_playback) 1319 if (is_playback)
1320 subs->datapipe = usb_sndisocpipe(dev, ep); 1320 subs->datapipe = usb_sndisocpipe(dev, ep);
1321 else 1321 else
1322 subs->datapipe = usb_rcvisocpipe(dev, ep); 1322 subs->datapipe = usb_rcvisocpipe(dev, ep);
1323 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH && 1323 if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH &&
1324 get_endpoint(alts, 0)->bInterval >= 1 && 1324 get_endpoint(alts, 0)->bInterval >= 1 &&
1325 get_endpoint(alts, 0)->bInterval <= 4) 1325 get_endpoint(alts, 0)->bInterval <= 4)
1326 subs->datainterval = get_endpoint(alts, 0)->bInterval - 1; 1326 subs->datainterval = get_endpoint(alts, 0)->bInterval - 1;
1327 else 1327 else
1328 subs->datainterval = 0; 1328 subs->datainterval = 0;
1329 subs->syncpipe = subs->syncinterval = 0; 1329 subs->syncpipe = subs->syncinterval = 0;
1330 subs->maxpacksize = fmt->maxpacksize; 1330 subs->maxpacksize = fmt->maxpacksize;
1331 subs->fill_max = 0; 1331 subs->fill_max = 0;
1332 1332
1333 /* we need a sync pipe in async OUT or adaptive IN mode */ 1333 /* we need a sync pipe in async OUT or adaptive IN mode */
1334 /* check the number of EP, since some devices have broken 1334 /* check the number of EP, since some devices have broken
1335 * descriptors which fool us. if it has only one EP, 1335 * descriptors which fool us. if it has only one EP,
1336 * assume it as adaptive-out or sync-in. 1336 * assume it as adaptive-out or sync-in.
1337 */ 1337 */
1338 attr = fmt->ep_attr & EP_ATTR_MASK; 1338 attr = fmt->ep_attr & EP_ATTR_MASK;
1339 if (((is_playback && attr == EP_ATTR_ASYNC) || 1339 if (((is_playback && attr == EP_ATTR_ASYNC) ||
1340 (! is_playback && attr == EP_ATTR_ADAPTIVE)) && 1340 (! is_playback && attr == EP_ATTR_ADAPTIVE)) &&
1341 altsd->bNumEndpoints >= 2) { 1341 altsd->bNumEndpoints >= 2) {
1342 /* check sync-pipe endpoint */ 1342 /* check sync-pipe endpoint */
1343 /* ... and check descriptor size before accessing bSynchAddress 1343 /* ... and check descriptor size before accessing bSynchAddress
1344 because there is a version of the SB Audigy 2 NX firmware lacking 1344 because there is a version of the SB Audigy 2 NX firmware lacking
1345 the audio fields in the endpoint descriptors */ 1345 the audio fields in the endpoint descriptors */
1346 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 || 1346 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
1347 (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && 1347 (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1348 get_endpoint(alts, 1)->bSynchAddress != 0)) { 1348 get_endpoint(alts, 1)->bSynchAddress != 0)) {
1349 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n", 1349 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1350 dev->devnum, fmt->iface, fmt->altsetting); 1350 dev->devnum, fmt->iface, fmt->altsetting);
1351 return -EINVAL; 1351 return -EINVAL;
1352 } 1352 }
1353 ep = get_endpoint(alts, 1)->bEndpointAddress; 1353 ep = get_endpoint(alts, 1)->bEndpointAddress;
1354 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && 1354 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1355 (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) || 1355 (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
1356 (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) { 1356 (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
1357 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n", 1357 snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1358 dev->devnum, fmt->iface, fmt->altsetting); 1358 dev->devnum, fmt->iface, fmt->altsetting);
1359 return -EINVAL; 1359 return -EINVAL;
1360 } 1360 }
1361 ep &= USB_ENDPOINT_NUMBER_MASK; 1361 ep &= USB_ENDPOINT_NUMBER_MASK;
1362 if (is_playback) 1362 if (is_playback)
1363 subs->syncpipe = usb_rcvisocpipe(dev, ep); 1363 subs->syncpipe = usb_rcvisocpipe(dev, ep);
1364 else 1364 else
1365 subs->syncpipe = usb_sndisocpipe(dev, ep); 1365 subs->syncpipe = usb_sndisocpipe(dev, ep);
1366 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && 1366 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1367 get_endpoint(alts, 1)->bRefresh >= 1 && 1367 get_endpoint(alts, 1)->bRefresh >= 1 &&
1368 get_endpoint(alts, 1)->bRefresh <= 9) 1368 get_endpoint(alts, 1)->bRefresh <= 9)
1369 subs->syncinterval = get_endpoint(alts, 1)->bRefresh; 1369 subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
1370 else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) 1370 else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1371 subs->syncinterval = 1; 1371 subs->syncinterval = 1;
1372 else if (get_endpoint(alts, 1)->bInterval >= 1 && 1372 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
1373 get_endpoint(alts, 1)->bInterval <= 16) 1373 get_endpoint(alts, 1)->bInterval <= 16)
1374 subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1; 1374 subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
1375 else 1375 else
1376 subs->syncinterval = 3; 1376 subs->syncinterval = 3;
1377 } 1377 }
1378 1378
1379 /* always fill max packet size */ 1379 /* always fill max packet size */
1380 if (fmt->attributes & EP_CS_ATTR_FILL_MAX) 1380 if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
1381 subs->fill_max = 1; 1381 subs->fill_max = 1;
1382 1382
1383 if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0) 1383 if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
1384 return err; 1384 return err;
1385 1385
1386 subs->cur_audiofmt = fmt; 1386 subs->cur_audiofmt = fmt;
1387 1387
1388 #if 0 1388 #if 0
1389 printk("setting done: format = %d, rate = %d, channels = %d\n", 1389 printk("setting done: format = %d, rate = %d, channels = %d\n",
1390 fmt->format, fmt->rate, fmt->channels); 1390 fmt->format, fmt->rate, fmt->channels);
1391 printk(" datapipe = 0x%0x, syncpipe = 0x%0x\n", 1391 printk(" datapipe = 0x%0x, syncpipe = 0x%0x\n",
1392 subs->datapipe, subs->syncpipe); 1392 subs->datapipe, subs->syncpipe);
1393 #endif 1393 #endif
1394 1394
1395 return 0; 1395 return 0;
1396 } 1396 }
1397 1397
1398 /* 1398 /*
1399 * hw_params callback 1399 * hw_params callback
1400 * 1400 *
1401 * allocate a buffer and set the given audio format. 1401 * allocate a buffer and set the given audio format.
1402 * 1402 *
1403 * so far we use a physically linear buffer although packetize transfer 1403 * so far we use a physically linear buffer although packetize transfer
1404 * doesn't need a continuous area. 1404 * doesn't need a continuous area.
1405 * if sg buffer is supported on the later version of alsa, we'll follow 1405 * if sg buffer is supported on the later version of alsa, we'll follow
1406 * that. 1406 * that.
1407 */ 1407 */
1408 static int snd_usb_hw_params(struct snd_pcm_substream *substream, 1408 static int snd_usb_hw_params(struct snd_pcm_substream *substream,
1409 struct snd_pcm_hw_params *hw_params) 1409 struct snd_pcm_hw_params *hw_params)
1410 { 1410 {
1411 struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data; 1411 struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data;
1412 struct audioformat *fmt; 1412 struct audioformat *fmt;
1413 unsigned int channels, rate, format; 1413 unsigned int channels, rate, format;
1414 int ret, changed; 1414 int ret, changed;
1415 1415
1416 ret = snd_pcm_alloc_vmalloc_buffer(substream, 1416 ret = snd_pcm_alloc_vmalloc_buffer(substream,
1417 params_buffer_bytes(hw_params)); 1417 params_buffer_bytes(hw_params));
1418 if (ret < 0) 1418 if (ret < 0)
1419 return ret; 1419 return ret;
1420 1420
1421 format = params_format(hw_params); 1421 format = params_format(hw_params);
1422 rate = params_rate(hw_params); 1422 rate = params_rate(hw_params);
1423 channels = params_channels(hw_params); 1423 channels = params_channels(hw_params);
1424 fmt = find_format(subs, format, rate, channels); 1424 fmt = find_format(subs, format, rate, channels);
1425 if (! fmt) { 1425 if (! fmt) {
1426 snd_printd(KERN_DEBUG "cannot set format: format = 0x%x, rate = %d, channels = %d\n", 1426 snd_printd(KERN_DEBUG "cannot set format: format = 0x%x, rate = %d, channels = %d\n",
1427 format, rate, channels); 1427 format, rate, channels);
1428 return -EINVAL; 1428 return -EINVAL;
1429 } 1429 }
1430 1430
1431 changed = subs->cur_audiofmt != fmt || 1431 changed = subs->cur_audiofmt != fmt ||
1432 subs->period_bytes != params_period_bytes(hw_params) || 1432 subs->period_bytes != params_period_bytes(hw_params) ||
1433 subs->cur_rate != rate; 1433 subs->cur_rate != rate;
1434 if ((ret = set_format(subs, fmt)) < 0) 1434 if ((ret = set_format(subs, fmt)) < 0)
1435 return ret; 1435 return ret;
1436 1436
1437 if (subs->cur_rate != rate) { 1437 if (subs->cur_rate != rate) {
1438 struct usb_host_interface *alts; 1438 struct usb_host_interface *alts;
1439 struct usb_interface *iface; 1439 struct usb_interface *iface;
1440 iface = usb_ifnum_to_if(subs->dev, fmt->iface); 1440 iface = usb_ifnum_to_if(subs->dev, fmt->iface);
1441 alts = &iface->altsetting[fmt->altset_idx]; 1441 alts = &iface->altsetting[fmt->altset_idx];
1442 ret = init_usb_sample_rate(subs->dev, subs->interface, alts, fmt, rate); 1442 ret = init_usb_sample_rate(subs->dev, subs->interface, alts, fmt, rate);
1443 if (ret < 0) 1443 if (ret < 0)
1444 return ret; 1444 return ret;
1445 subs->cur_rate = rate; 1445 subs->cur_rate = rate;
1446 } 1446 }
1447 1447
1448 if (changed) { 1448 if (changed) {
1449 /* format changed */ 1449 /* format changed */
1450 release_substream_urbs(subs, 0); 1450 release_substream_urbs(subs, 0);
1451 /* influenced: period_bytes, channels, rate, format, */ 1451 /* influenced: period_bytes, channels, rate, format, */
1452 ret = init_substream_urbs(subs, params_period_bytes(hw_params), 1452 ret = init_substream_urbs(subs, params_period_bytes(hw_params),
1453 params_rate(hw_params), 1453 params_rate(hw_params),
1454 snd_pcm_format_physical_width(params_format(hw_params)) * params_channels(hw_params)); 1454 snd_pcm_format_physical_width(params_format(hw_params)) * params_channels(hw_params));
1455 } 1455 }
1456 1456
1457 return ret; 1457 return ret;
1458 } 1458 }
1459 1459
1460 /* 1460 /*
1461 * hw_free callback 1461 * hw_free callback
1462 * 1462 *
1463 * reset the audio format and release the buffer 1463 * reset the audio format and release the buffer
1464 */ 1464 */
1465 static int snd_usb_hw_free(struct snd_pcm_substream *substream) 1465 static int snd_usb_hw_free(struct snd_pcm_substream *substream)
1466 { 1466 {
1467 struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data; 1467 struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data;
1468 1468
1469 subs->cur_audiofmt = NULL; 1469 subs->cur_audiofmt = NULL;
1470 subs->cur_rate = 0; 1470 subs->cur_rate = 0;
1471 subs->period_bytes = 0; 1471 subs->period_bytes = 0;
1472 release_substream_urbs(subs, 0); 1472 release_substream_urbs(subs, 0);
1473 return snd_pcm_free_vmalloc_buffer(substream); 1473 return snd_pcm_free_vmalloc_buffer(substream);
1474 } 1474 }
1475 1475
1476 /* 1476 /*
1477 * prepare callback 1477 * prepare callback
1478 * 1478 *
1479 * only a few subtle things... 1479 * only a few subtle things...
1480 */ 1480 */
1481 static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream) 1481 static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
1482 { 1482 {
1483 struct snd_pcm_runtime *runtime = substream->runtime; 1483 struct snd_pcm_runtime *runtime = substream->runtime;
1484 struct snd_usb_substream *subs = runtime->private_data; 1484 struct snd_usb_substream *subs = runtime->private_data;
1485 1485
1486 if (! subs->cur_audiofmt) { 1486 if (! subs->cur_audiofmt) {
1487 snd_printk(KERN_ERR "usbaudio: no format is specified!\n"); 1487 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
1488 return -ENXIO; 1488 return -ENXIO;
1489 } 1489 }
1490 1490
1491 /* some unit conversions in runtime */ 1491 /* some unit conversions in runtime */
1492 subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize); 1492 subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
1493 subs->curframesize = bytes_to_frames(runtime, subs->curpacksize); 1493 subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
1494 1494
1495 /* reset the pointer */ 1495 /* reset the pointer */
1496 subs->hwptr_done = 0; 1496 subs->hwptr_done = 0;
1497 subs->transfer_done = 0; 1497 subs->transfer_done = 0;
1498 subs->phase = 0; 1498 subs->phase = 0;
1499 1499
1500 /* clear urbs (to be sure) */ 1500 /* clear urbs (to be sure) */
1501 deactivate_urbs(subs, 0, 1); 1501 deactivate_urbs(subs, 0, 1);
1502 wait_clear_urbs(subs); 1502 wait_clear_urbs(subs);
1503 1503
1504 /* for playback, submit the URBs now; otherwise, the first hwptr_done 1504 /* for playback, submit the URBs now; otherwise, the first hwptr_done
1505 * updates for all URBs would happen at the same time when starting */ 1505 * updates for all URBs would happen at the same time when starting */
1506 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) { 1506 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1507 subs->ops.prepare = prepare_startup_playback_urb; 1507 subs->ops.prepare = prepare_startup_playback_urb;
1508 return start_urbs(subs, runtime); 1508 return start_urbs(subs, runtime);
1509 } else 1509 } else
1510 return 0; 1510 return 0;
1511 } 1511 }
1512 1512
1513 static struct snd_pcm_hardware snd_usb_playback = 1513 static struct snd_pcm_hardware snd_usb_playback =
1514 { 1514 {
1515 .info = SNDRV_PCM_INFO_MMAP | 1515 .info = SNDRV_PCM_INFO_MMAP |
1516 SNDRV_PCM_INFO_MMAP_VALID | 1516 SNDRV_PCM_INFO_MMAP_VALID |
1517 SNDRV_PCM_INFO_BATCH | 1517 SNDRV_PCM_INFO_BATCH |
1518 SNDRV_PCM_INFO_INTERLEAVED | 1518 SNDRV_PCM_INFO_INTERLEAVED |
1519 SNDRV_PCM_INFO_BLOCK_TRANSFER, 1519 SNDRV_PCM_INFO_BLOCK_TRANSFER,
1520 .buffer_bytes_max = 1024 * 1024, 1520 .buffer_bytes_max = 1024 * 1024,
1521 .period_bytes_min = 64, 1521 .period_bytes_min = 64,
1522 .period_bytes_max = 512 * 1024, 1522 .period_bytes_max = 512 * 1024,
1523 .periods_min = 2, 1523 .periods_min = 2,
1524 .periods_max = 1024, 1524 .periods_max = 1024,
1525 }; 1525 };
1526 1526
1527 static struct snd_pcm_hardware snd_usb_capture = 1527 static struct snd_pcm_hardware snd_usb_capture =
1528 { 1528 {
1529 .info = SNDRV_PCM_INFO_MMAP | 1529 .info = SNDRV_PCM_INFO_MMAP |
1530 SNDRV_PCM_INFO_MMAP_VALID | 1530 SNDRV_PCM_INFO_MMAP_VALID |
1531 SNDRV_PCM_INFO_BATCH | 1531 SNDRV_PCM_INFO_BATCH |
1532 SNDRV_PCM_INFO_INTERLEAVED | 1532 SNDRV_PCM_INFO_INTERLEAVED |
1533 SNDRV_PCM_INFO_BLOCK_TRANSFER, 1533 SNDRV_PCM_INFO_BLOCK_TRANSFER,
1534 .buffer_bytes_max = 1024 * 1024, 1534 .buffer_bytes_max = 1024 * 1024,
1535 .period_bytes_min = 64, 1535 .period_bytes_min = 64,
1536 .period_bytes_max = 512 * 1024, 1536 .period_bytes_max = 512 * 1024,
1537 .periods_min = 2, 1537 .periods_min = 2,
1538 .periods_max = 1024, 1538 .periods_max = 1024,
1539 }; 1539 };
1540 1540
1541 /* 1541 /*
1542 * h/w constraints 1542 * h/w constraints
1543 */ 1543 */
1544 1544
1545 #ifdef HW_CONST_DEBUG 1545 #ifdef HW_CONST_DEBUG
1546 #define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args) 1546 #define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
1547 #else 1547 #else
1548 #define hwc_debug(fmt, args...) /**/ 1548 #define hwc_debug(fmt, args...) /**/
1549 #endif 1549 #endif
1550 1550
1551 static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audioformat *fp) 1551 static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audioformat *fp)
1552 { 1552 {
1553 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 1553 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1554 struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 1554 struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1555 struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 1555 struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1556 1556
1557 /* check the format */ 1557 /* check the format */
1558 if (! snd_mask_test(fmts, fp->format)) { 1558 if (! snd_mask_test(fmts, fp->format)) {
1559 hwc_debug(" > check: no supported format %d\n", fp->format); 1559 hwc_debug(" > check: no supported format %d\n", fp->format);
1560 return 0; 1560 return 0;
1561 } 1561 }
1562 /* check the channels */ 1562 /* check the channels */
1563 if (fp->channels < ct->min || fp->channels > ct->max) { 1563 if (fp->channels < ct->min || fp->channels > ct->max) {
1564 hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max); 1564 hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
1565 return 0; 1565 return 0;
1566 } 1566 }
1567 /* check the rate is within the range */ 1567 /* check the rate is within the range */
1568 if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) { 1568 if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
1569 hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max); 1569 hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max);
1570 return 0; 1570 return 0;
1571 } 1571 }
1572 if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) { 1572 if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
1573 hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min); 1573 hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min);
1574 return 0; 1574 return 0;
1575 } 1575 }
1576 return 1; 1576 return 1;
1577 } 1577 }
1578 1578
1579 static int hw_rule_rate(struct snd_pcm_hw_params *params, 1579 static int hw_rule_rate(struct snd_pcm_hw_params *params,
1580 struct snd_pcm_hw_rule *rule) 1580 struct snd_pcm_hw_rule *rule)
1581 { 1581 {
1582 struct snd_usb_substream *subs = rule->private; 1582 struct snd_usb_substream *subs = rule->private;
1583 struct list_head *p; 1583 struct list_head *p;
1584 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 1584 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1585 unsigned int rmin, rmax; 1585 unsigned int rmin, rmax;
1586 int changed; 1586 int changed;
1587 1587
1588 hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max); 1588 hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
1589 changed = 0; 1589 changed = 0;
1590 rmin = rmax = 0; 1590 rmin = rmax = 0;
1591 list_for_each(p, &subs->fmt_list) { 1591 list_for_each(p, &subs->fmt_list) {
1592 struct audioformat *fp; 1592 struct audioformat *fp;
1593 fp = list_entry(p, struct audioformat, list); 1593 fp = list_entry(p, struct audioformat, list);
1594 if (! hw_check_valid_format(params, fp)) 1594 if (! hw_check_valid_format(params, fp))
1595 continue; 1595 continue;
1596 if (changed++) { 1596 if (changed++) {
1597 if (rmin > fp->rate_min) 1597 if (rmin > fp->rate_min)
1598 rmin = fp->rate_min; 1598 rmin = fp->rate_min;
1599 if (rmax < fp->rate_max) 1599 if (rmax < fp->rate_max)
1600 rmax = fp->rate_max; 1600 rmax = fp->rate_max;
1601 } else { 1601 } else {
1602 rmin = fp->rate_min; 1602 rmin = fp->rate_min;
1603 rmax = fp->rate_max; 1603 rmax = fp->rate_max;
1604 } 1604 }
1605 } 1605 }
1606 1606
1607 if (! changed) { 1607 if (! changed) {
1608 hwc_debug(" --> get empty\n"); 1608 hwc_debug(" --> get empty\n");
1609 it->empty = 1; 1609 it->empty = 1;
1610 return -EINVAL; 1610 return -EINVAL;
1611 } 1611 }
1612 1612
1613 changed = 0; 1613 changed = 0;
1614 if (it->min < rmin) { 1614 if (it->min < rmin) {
1615 it->min = rmin; 1615 it->min = rmin;
1616 it->openmin = 0; 1616 it->openmin = 0;
1617 changed = 1; 1617 changed = 1;
1618 } 1618 }
1619 if (it->max > rmax) { 1619 if (it->max > rmax) {
1620 it->max = rmax; 1620 it->max = rmax;
1621 it->openmax = 0; 1621 it->openmax = 0;
1622 changed = 1; 1622 changed = 1;
1623 } 1623 }
1624 if (snd_interval_checkempty(it)) { 1624 if (snd_interval_checkempty(it)) {
1625 it->empty = 1; 1625 it->empty = 1;
1626 return -EINVAL; 1626 return -EINVAL;
1627 } 1627 }
1628 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed); 1628 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1629 return changed; 1629 return changed;
1630 } 1630 }
1631 1631
1632 1632
1633 static int hw_rule_channels(struct snd_pcm_hw_params *params, 1633 static int hw_rule_channels(struct snd_pcm_hw_params *params,
1634 struct snd_pcm_hw_rule *rule) 1634 struct snd_pcm_hw_rule *rule)
1635 { 1635 {
1636 struct snd_usb_substream *subs = rule->private; 1636 struct snd_usb_substream *subs = rule->private;
1637 struct list_head *p; 1637 struct list_head *p;
1638 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 1638 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1639 unsigned int rmin, rmax; 1639 unsigned int rmin, rmax;
1640 int changed; 1640 int changed;
1641 1641
1642 hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max); 1642 hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
1643 changed = 0; 1643 changed = 0;
1644 rmin = rmax = 0; 1644 rmin = rmax = 0;
1645 list_for_each(p, &subs->fmt_list) { 1645 list_for_each(p, &subs->fmt_list) {
1646 struct audioformat *fp; 1646 struct audioformat *fp;
1647 fp = list_entry(p, struct audioformat, list); 1647 fp = list_entry(p, struct audioformat, list);
1648 if (! hw_check_valid_format(params, fp)) 1648 if (! hw_check_valid_format(params, fp))
1649 continue; 1649 continue;
1650 if (changed++) { 1650 if (changed++) {
1651 if (rmin > fp->channels) 1651 if (rmin > fp->channels)
1652 rmin = fp->channels; 1652 rmin = fp->channels;
1653 if (rmax < fp->channels) 1653 if (rmax < fp->channels)
1654 rmax = fp->channels; 1654 rmax = fp->channels;
1655 } else { 1655 } else {
1656 rmin = fp->channels; 1656 rmin = fp->channels;
1657 rmax = fp->channels; 1657 rmax = fp->channels;
1658 } 1658 }
1659 } 1659 }
1660 1660
1661 if (! changed) { 1661 if (! changed) {
1662 hwc_debug(" --> get empty\n"); 1662 hwc_debug(" --> get empty\n");
1663 it->empty = 1; 1663 it->empty = 1;
1664 return -EINVAL; 1664 return -EINVAL;
1665 } 1665 }
1666 1666
1667 changed = 0; 1667 changed = 0;
1668 if (it->min < rmin) { 1668 if (it->min < rmin) {
1669 it->min = rmin; 1669 it->min = rmin;
1670 it->openmin = 0; 1670 it->openmin = 0;
1671 changed = 1; 1671 changed = 1;
1672 } 1672 }
1673 if (it->max > rmax) { 1673 if (it->max > rmax) {
1674 it->max = rmax; 1674 it->max = rmax;
1675 it->openmax = 0; 1675 it->openmax = 0;
1676 changed = 1; 1676 changed = 1;
1677 } 1677 }
1678 if (snd_interval_checkempty(it)) { 1678 if (snd_interval_checkempty(it)) {
1679 it->empty = 1; 1679 it->empty = 1;
1680 return -EINVAL; 1680 return -EINVAL;
1681 } 1681 }
1682 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed); 1682 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1683 return changed; 1683 return changed;
1684 } 1684 }
1685 1685
1686 static int hw_rule_format(struct snd_pcm_hw_params *params, 1686 static int hw_rule_format(struct snd_pcm_hw_params *params,
1687 struct snd_pcm_hw_rule *rule) 1687 struct snd_pcm_hw_rule *rule)
1688 { 1688 {
1689 struct snd_usb_substream *subs = rule->private; 1689 struct snd_usb_substream *subs = rule->private;
1690 struct list_head *p; 1690 struct list_head *p;
1691 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 1691 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1692 u64 fbits; 1692 u64 fbits;
1693 u32 oldbits[2]; 1693 u32 oldbits[2];
1694 int changed; 1694 int changed;
1695 1695
1696 hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]); 1696 hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
1697 fbits = 0; 1697 fbits = 0;
1698 list_for_each(p, &subs->fmt_list) { 1698 list_for_each(p, &subs->fmt_list) {
1699 struct audioformat *fp; 1699 struct audioformat *fp;
1700 fp = list_entry(p, struct audioformat, list); 1700 fp = list_entry(p, struct audioformat, list);
1701 if (! hw_check_valid_format(params, fp)) 1701 if (! hw_check_valid_format(params, fp))
1702 continue; 1702 continue;
1703 fbits |= (1ULL << fp->format); 1703 fbits |= (1ULL << fp->format);
1704 } 1704 }
1705 1705
1706 oldbits[0] = fmt->bits[0]; 1706 oldbits[0] = fmt->bits[0];
1707 oldbits[1] = fmt->bits[1]; 1707 oldbits[1] = fmt->bits[1];
1708 fmt->bits[0] &= (u32)fbits; 1708 fmt->bits[0] &= (u32)fbits;
1709 fmt->bits[1] &= (u32)(fbits >> 32); 1709 fmt->bits[1] &= (u32)(fbits >> 32);
1710 if (! fmt->bits[0] && ! fmt->bits[1]) { 1710 if (! fmt->bits[0] && ! fmt->bits[1]) {
1711 hwc_debug(" --> get empty\n"); 1711 hwc_debug(" --> get empty\n");
1712 return -EINVAL; 1712 return -EINVAL;
1713 } 1713 }
1714 changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]); 1714 changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
1715 hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed); 1715 hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
1716 return changed; 1716 return changed;
1717 } 1717 }
1718 1718
1719 #define MAX_MASK 64 1719 #define MAX_MASK 64
1720 1720
1721 /* 1721 /*
1722 * check whether the registered audio formats need special hw-constraints 1722 * check whether the registered audio formats need special hw-constraints
1723 */ 1723 */
1724 static int check_hw_params_convention(struct snd_usb_substream *subs) 1724 static int check_hw_params_convention(struct snd_usb_substream *subs)
1725 { 1725 {
1726 int i; 1726 int i;
1727 u32 *channels; 1727 u32 *channels;
1728 u32 *rates; 1728 u32 *rates;
1729 u32 cmaster, rmaster; 1729 u32 cmaster, rmaster;
1730 u32 rate_min = 0, rate_max = 0; 1730 u32 rate_min = 0, rate_max = 0;
1731 struct list_head *p; 1731 struct list_head *p;
1732 int err = 1; 1732 int err = 1;
1733 1733
1734 channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL); 1734 channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1735 rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL); 1735 rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1736 1736
1737 list_for_each(p, &subs->fmt_list) { 1737 list_for_each(p, &subs->fmt_list) {
1738 struct audioformat *f; 1738 struct audioformat *f;
1739 f = list_entry(p, struct audioformat, list); 1739 f = list_entry(p, struct audioformat, list);
1740 /* unconventional channels? */ 1740 /* unconventional channels? */
1741 if (f->channels > 32) 1741 if (f->channels > 32)
1742 goto __out; 1742 goto __out;
1743 /* continuous rate min/max matches? */ 1743 /* continuous rate min/max matches? */
1744 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) { 1744 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1745 if (rate_min && f->rate_min != rate_min) 1745 if (rate_min && f->rate_min != rate_min)
1746 goto __out; 1746 goto __out;
1747 if (rate_max && f->rate_max != rate_max) 1747 if (rate_max && f->rate_max != rate_max)
1748 goto __out; 1748 goto __out;
1749 rate_min = f->rate_min; 1749 rate_min = f->rate_min;
1750 rate_max = f->rate_max; 1750 rate_max = f->rate_max;
1751 } 1751 }
1752 /* combination of continuous rates and fixed rates? */ 1752 /* combination of continuous rates and fixed rates? */
1753 if (rates[f->format] & SNDRV_PCM_RATE_CONTINUOUS) { 1753 if (rates[f->format] & SNDRV_PCM_RATE_CONTINUOUS) {
1754 if (f->rates != rates[f->format]) 1754 if (f->rates != rates[f->format])
1755 goto __out; 1755 goto __out;
1756 } 1756 }
1757 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) { 1757 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1758 if (rates[f->format] && rates[f->format] != f->rates) 1758 if (rates[f->format] && rates[f->format] != f->rates)
1759 goto __out; 1759 goto __out;
1760 } 1760 }
1761 channels[f->format] |= (1 << f->channels); 1761 channels[f->format] |= (1 << f->channels);
1762 rates[f->format] |= f->rates; 1762 rates[f->format] |= f->rates;
1763 /* needs knot? */ 1763 /* needs knot? */
1764 if (f->needs_knot) 1764 if (f->needs_knot)
1765 goto __out; 1765 goto __out;
1766 } 1766 }
1767 /* check whether channels and rates match for all formats */ 1767 /* check whether channels and rates match for all formats */
1768 cmaster = rmaster = 0; 1768 cmaster = rmaster = 0;
1769 for (i = 0; i < MAX_MASK; i++) { 1769 for (i = 0; i < MAX_MASK; i++) {
1770 if (cmaster != channels[i] && cmaster && channels[i]) 1770 if (cmaster != channels[i] && cmaster && channels[i])
1771 goto __out; 1771 goto __out;
1772 if (rmaster != rates[i] && rmaster && rates[i]) 1772 if (rmaster != rates[i] && rmaster && rates[i])
1773 goto __out; 1773 goto __out;
1774 if (channels[i]) 1774 if (channels[i])
1775 cmaster = channels[i]; 1775 cmaster = channels[i];
1776 if (rates[i]) 1776 if (rates[i])
1777 rmaster = rates[i]; 1777 rmaster = rates[i];
1778 } 1778 }
1779 /* check whether channels match for all distinct rates */ 1779 /* check whether channels match for all distinct rates */
1780 memset(channels, 0, MAX_MASK * sizeof(u32)); 1780 memset(channels, 0, MAX_MASK * sizeof(u32));
1781 list_for_each(p, &subs->fmt_list) { 1781 list_for_each(p, &subs->fmt_list) {
1782 struct audioformat *f; 1782 struct audioformat *f;
1783 f = list_entry(p, struct audioformat, list); 1783 f = list_entry(p, struct audioformat, list);
1784 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) 1784 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS)
1785 continue; 1785 continue;
1786 for (i = 0; i < 32; i++) { 1786 for (i = 0; i < 32; i++) {
1787 if (f->rates & (1 << i)) 1787 if (f->rates & (1 << i))
1788 channels[i] |= (1 << f->channels); 1788 channels[i] |= (1 << f->channels);
1789 } 1789 }
1790 } 1790 }
1791 cmaster = 0; 1791 cmaster = 0;
1792 for (i = 0; i < 32; i++) { 1792 for (i = 0; i < 32; i++) {
1793 if (cmaster != channels[i] && cmaster && channels[i]) 1793 if (cmaster != channels[i] && cmaster && channels[i])
1794 goto __out; 1794 goto __out;
1795 if (channels[i]) 1795 if (channels[i])
1796 cmaster = channels[i]; 1796 cmaster = channels[i];
1797 } 1797 }
1798 err = 0; 1798 err = 0;
1799 1799
1800 __out: 1800 __out:
1801 kfree(channels); 1801 kfree(channels);
1802 kfree(rates); 1802 kfree(rates);
1803 return err; 1803 return err;
1804 } 1804 }
1805 1805
1806 /* 1806 /*
1807 * If the device supports unusual bit rates, does the request meet these? 1807 * If the device supports unusual bit rates, does the request meet these?
1808 */ 1808 */
1809 static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime, 1809 static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
1810 struct snd_usb_substream *subs) 1810 struct snd_usb_substream *subs)
1811 { 1811 {
1812 struct list_head *p; 1812 struct list_head *p;
1813 struct snd_pcm_hw_constraint_list constraints_rates; 1813 struct snd_pcm_hw_constraint_list constraints_rates;
1814 int err; 1814 int err;
1815 1815
1816 list_for_each(p, &subs->fmt_list) { 1816 list_for_each(p, &subs->fmt_list) {
1817 struct audioformat *fp; 1817 struct audioformat *fp;
1818 fp = list_entry(p, struct audioformat, list); 1818 fp = list_entry(p, struct audioformat, list);
1819 1819
1820 if (!fp->needs_knot) 1820 if (!fp->needs_knot)
1821 continue; 1821 continue;
1822 1822
1823 constraints_rates.count = fp->nr_rates; 1823 constraints_rates.count = fp->nr_rates;
1824 constraints_rates.list = fp->rate_table; 1824 constraints_rates.list = fp->rate_table;
1825 constraints_rates.mask = 0; 1825 constraints_rates.mask = 0;
1826 1826
1827 err = snd_pcm_hw_constraint_list(runtime, 0, 1827 err = snd_pcm_hw_constraint_list(runtime, 0,
1828 SNDRV_PCM_HW_PARAM_RATE, 1828 SNDRV_PCM_HW_PARAM_RATE,
1829 &constraints_rates); 1829 &constraints_rates);
1830 1830
1831 if (err < 0) 1831 if (err < 0)
1832 return err; 1832 return err;
1833 } 1833 }
1834 1834
1835 return 0; 1835 return 0;
1836 } 1836 }
1837 1837
1838 1838
1839 /* 1839 /*
1840 * set up the runtime hardware information. 1840 * set up the runtime hardware information.
1841 */ 1841 */
1842 1842
1843 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs) 1843 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
1844 { 1844 {
1845 struct list_head *p; 1845 struct list_head *p;
1846 int err; 1846 int err;
1847 1847
1848 runtime->hw.formats = subs->formats; 1848 runtime->hw.formats = subs->formats;
1849 1849
1850 runtime->hw.rate_min = 0x7fffffff; 1850 runtime->hw.rate_min = 0x7fffffff;
1851 runtime->hw.rate_max = 0; 1851 runtime->hw.rate_max = 0;
1852 runtime->hw.channels_min = 256; 1852 runtime->hw.channels_min = 256;
1853 runtime->hw.channels_max = 0; 1853 runtime->hw.channels_max = 0;
1854 runtime->hw.rates = 0; 1854 runtime->hw.rates = 0;
1855 /* check min/max rates and channels */ 1855 /* check min/max rates and channels */
1856 list_for_each(p, &subs->fmt_list) { 1856 list_for_each(p, &subs->fmt_list) {
1857 struct audioformat *fp; 1857 struct audioformat *fp;
1858 fp = list_entry(p, struct audioformat, list); 1858 fp = list_entry(p, struct audioformat, list);
1859 runtime->hw.rates |= fp->rates; 1859 runtime->hw.rates |= fp->rates;
1860 if (runtime->hw.rate_min > fp->rate_min) 1860 if (runtime->hw.rate_min > fp->rate_min)
1861 runtime->hw.rate_min = fp->rate_min; 1861 runtime->hw.rate_min = fp->rate_min;
1862 if (runtime->hw.rate_max < fp->rate_max) 1862 if (runtime->hw.rate_max < fp->rate_max)
1863 runtime->hw.rate_max = fp->rate_max; 1863 runtime->hw.rate_max = fp->rate_max;
1864 if (runtime->hw.channels_min > fp->channels) 1864 if (runtime->hw.channels_min > fp->channels)
1865 runtime->hw.channels_min = fp->channels; 1865 runtime->hw.channels_min = fp->channels;
1866 if (runtime->hw.channels_max < fp->channels) 1866 if (runtime->hw.channels_max < fp->channels)
1867 runtime->hw.channels_max = fp->channels; 1867 runtime->hw.channels_max = fp->channels;
1868 if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) { 1868 if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) {
1869 /* FIXME: there might be more than one audio formats... */ 1869 /* FIXME: there might be more than one audio formats... */
1870 runtime->hw.period_bytes_min = runtime->hw.period_bytes_max = 1870 runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
1871 fp->frame_size; 1871 fp->frame_size;
1872 } 1872 }
1873 } 1873 }
1874 1874
1875 /* set the period time minimum 1ms */ 1875 /* set the period time minimum 1ms */
1876 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1876 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1877 1000 * MIN_PACKS_URB, 1877 1000 * MIN_PACKS_URB,
1878 /*(nrpacks * MAX_URBS) * 1000*/ UINT_MAX); 1878 /*(nrpacks * MAX_URBS) * 1000*/ UINT_MAX);
1879 1879
1880 if (check_hw_params_convention(subs)) { 1880 if (check_hw_params_convention(subs)) {
1881 hwc_debug("setting extra hw constraints...\n"); 1881 hwc_debug("setting extra hw constraints...\n");
1882 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 1882 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1883 hw_rule_rate, subs, 1883 hw_rule_rate, subs,
1884 SNDRV_PCM_HW_PARAM_FORMAT, 1884 SNDRV_PCM_HW_PARAM_FORMAT,
1885 SNDRV_PCM_HW_PARAM_CHANNELS, 1885 SNDRV_PCM_HW_PARAM_CHANNELS,
1886 -1)) < 0) 1886 -1)) < 0)
1887 return err; 1887 return err;
1888 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 1888 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1889 hw_rule_channels, subs, 1889 hw_rule_channels, subs,
1890 SNDRV_PCM_HW_PARAM_FORMAT, 1890 SNDRV_PCM_HW_PARAM_FORMAT,
1891 SNDRV_PCM_HW_PARAM_RATE, 1891 SNDRV_PCM_HW_PARAM_RATE,
1892 -1)) < 0) 1892 -1)) < 0)
1893 return err; 1893 return err;
1894 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, 1894 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1895 hw_rule_format, subs, 1895 hw_rule_format, subs,
1896 SNDRV_PCM_HW_PARAM_RATE, 1896 SNDRV_PCM_HW_PARAM_RATE,
1897 SNDRV_PCM_HW_PARAM_CHANNELS, 1897 SNDRV_PCM_HW_PARAM_CHANNELS,
1898 -1)) < 0) 1898 -1)) < 0)
1899 return err; 1899 return err;
1900 if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0) 1900 if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
1901 return err; 1901 return err;
1902 } 1902 }
1903 return 0; 1903 return 0;
1904 } 1904 }
1905 1905
1906 static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction, 1906 static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction,
1907 struct snd_pcm_hardware *hw) 1907 struct snd_pcm_hardware *hw)
1908 { 1908 {
1909 struct snd_usb_stream *as = snd_pcm_substream_chip(substream); 1909 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1910 struct snd_pcm_runtime *runtime = substream->runtime; 1910 struct snd_pcm_runtime *runtime = substream->runtime;
1911 struct snd_usb_substream *subs = &as->substream[direction]; 1911 struct snd_usb_substream *subs = &as->substream[direction];
1912 1912
1913 subs->interface = -1; 1913 subs->interface = -1;
1914 subs->format = 0; 1914 subs->format = 0;
1915 runtime->hw = *hw; 1915 runtime->hw = *hw;
1916 runtime->private_data = subs; 1916 runtime->private_data = subs;
1917 subs->pcm_substream = substream; 1917 subs->pcm_substream = substream;
1918 return setup_hw_info(runtime, subs); 1918 return setup_hw_info(runtime, subs);
1919 } 1919 }
1920 1920
1921 static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction) 1921 static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
1922 { 1922 {
1923 struct snd_usb_stream *as = snd_pcm_substream_chip(substream); 1923 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1924 struct snd_usb_substream *subs = &as->substream[direction]; 1924 struct snd_usb_substream *subs = &as->substream[direction];
1925 1925
1926 if (subs->interface >= 0) { 1926 if (subs->interface >= 0) {
1927 usb_set_interface(subs->dev, subs->interface, 0); 1927 usb_set_interface(subs->dev, subs->interface, 0);
1928 subs->interface = -1; 1928 subs->interface = -1;
1929 } 1929 }
1930 subs->pcm_substream = NULL; 1930 subs->pcm_substream = NULL;
1931 return 0; 1931 return 0;
1932 } 1932 }
1933 1933
1934 static int snd_usb_playback_open(struct snd_pcm_substream *substream) 1934 static int snd_usb_playback_open(struct snd_pcm_substream *substream)
1935 { 1935 {
1936 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback); 1936 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback);
1937 } 1937 }
1938 1938
1939 static int snd_usb_playback_close(struct snd_pcm_substream *substream) 1939 static int snd_usb_playback_close(struct snd_pcm_substream *substream)
1940 { 1940 {
1941 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK); 1941 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
1942 } 1942 }
1943 1943
1944 static int snd_usb_capture_open(struct snd_pcm_substream *substream) 1944 static int snd_usb_capture_open(struct snd_pcm_substream *substream)
1945 { 1945 {
1946 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture); 1946 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture);
1947 } 1947 }
1948 1948
1949 static int snd_usb_capture_close(struct snd_pcm_substream *substream) 1949 static int snd_usb_capture_close(struct snd_pcm_substream *substream)
1950 { 1950 {
1951 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE); 1951 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
1952 } 1952 }
1953 1953
1954 static struct snd_pcm_ops snd_usb_playback_ops = { 1954 static struct snd_pcm_ops snd_usb_playback_ops = {
1955 .open = snd_usb_playback_open, 1955 .open = snd_usb_playback_open,
1956 .close = snd_usb_playback_close, 1956 .close = snd_usb_playback_close,
1957 .ioctl = snd_pcm_lib_ioctl, 1957 .ioctl = snd_pcm_lib_ioctl,
1958 .hw_params = snd_usb_hw_params, 1958 .hw_params = snd_usb_hw_params,
1959 .hw_free = snd_usb_hw_free, 1959 .hw_free = snd_usb_hw_free,
1960 .prepare = snd_usb_pcm_prepare, 1960 .prepare = snd_usb_pcm_prepare,
1961 .trigger = snd_usb_pcm_playback_trigger, 1961 .trigger = snd_usb_pcm_playback_trigger,
1962 .pointer = snd_usb_pcm_pointer, 1962 .pointer = snd_usb_pcm_pointer,
1963 .page = snd_pcm_get_vmalloc_page, 1963 .page = snd_pcm_get_vmalloc_page,
1964 }; 1964 };
1965 1965
1966 static struct snd_pcm_ops snd_usb_capture_ops = { 1966 static struct snd_pcm_ops snd_usb_capture_ops = {
1967 .open = snd_usb_capture_open, 1967 .open = snd_usb_capture_open,
1968 .close = snd_usb_capture_close, 1968 .close = snd_usb_capture_close,
1969 .ioctl = snd_pcm_lib_ioctl, 1969 .ioctl = snd_pcm_lib_ioctl,
1970 .hw_params = snd_usb_hw_params, 1970 .hw_params = snd_usb_hw_params,
1971 .hw_free = snd_usb_hw_free, 1971 .hw_free = snd_usb_hw_free,
1972 .prepare = snd_usb_pcm_prepare, 1972 .prepare = snd_usb_pcm_prepare,
1973 .trigger = snd_usb_pcm_capture_trigger, 1973 .trigger = snd_usb_pcm_capture_trigger,
1974 .pointer = snd_usb_pcm_pointer, 1974 .pointer = snd_usb_pcm_pointer,
1975 .page = snd_pcm_get_vmalloc_page, 1975 .page = snd_pcm_get_vmalloc_page,
1976 }; 1976 };
1977 1977
1978 1978
1979 1979
1980 /* 1980 /*
1981 * helper functions 1981 * helper functions
1982 */ 1982 */
1983 1983
1984 /* 1984 /*
1985 * combine bytes and get an integer value 1985 * combine bytes and get an integer value
1986 */ 1986 */
1987 unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size) 1987 unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
1988 { 1988 {
1989 switch (size) { 1989 switch (size) {
1990 case 1: return *bytes; 1990 case 1: return *bytes;
1991 case 2: return combine_word(bytes); 1991 case 2: return combine_word(bytes);
1992 case 3: return combine_triple(bytes); 1992 case 3: return combine_triple(bytes);
1993 case 4: return combine_quad(bytes); 1993 case 4: return combine_quad(bytes);
1994 default: return 0; 1994 default: return 0;
1995 } 1995 }
1996 } 1996 }
1997 1997
1998 /* 1998 /*
1999 * parse descriptor buffer and return the pointer starting the given 1999 * parse descriptor buffer and return the pointer starting the given
2000 * descriptor type. 2000 * descriptor type.
2001 */ 2001 */
2002 void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype) 2002 void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype)
2003 { 2003 {
2004 u8 *p, *end, *next; 2004 u8 *p, *end, *next;
2005 2005
2006 p = descstart; 2006 p = descstart;
2007 end = p + desclen; 2007 end = p + desclen;
2008 for (; p < end;) { 2008 for (; p < end;) {
2009 if (p[0] < 2) 2009 if (p[0] < 2)
2010 return NULL; 2010 return NULL;
2011 next = p + p[0]; 2011 next = p + p[0];
2012 if (next > end) 2012 if (next > end)
2013 return NULL; 2013 return NULL;
2014 if (p[1] == dtype && (!after || (void *)p > after)) { 2014 if (p[1] == dtype && (!after || (void *)p > after)) {
2015 return p; 2015 return p;
2016 } 2016 }
2017 p = next; 2017 p = next;
2018 } 2018 }
2019 return NULL; 2019 return NULL;
2020 } 2020 }
2021 2021
2022 /* 2022 /*
2023 * find a class-specified interface descriptor with the given subtype. 2023 * find a class-specified interface descriptor with the given subtype.
2024 */ 2024 */
2025 void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype) 2025 void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype)
2026 { 2026 {
2027 unsigned char *p = after; 2027 unsigned char *p = after;
2028 2028
2029 while ((p = snd_usb_find_desc(buffer, buflen, p, 2029 while ((p = snd_usb_find_desc(buffer, buflen, p,
2030 USB_DT_CS_INTERFACE)) != NULL) { 2030 USB_DT_CS_INTERFACE)) != NULL) {
2031 if (p[0] >= 3 && p[2] == dsubtype) 2031 if (p[0] >= 3 && p[2] == dsubtype)
2032 return p; 2032 return p;
2033 } 2033 }
2034 return NULL; 2034 return NULL;
2035 } 2035 }
2036 2036
2037 /* 2037 /*
2038 * Wrapper for usb_control_msg(). 2038 * Wrapper for usb_control_msg().
2039 * Allocates a temp buffer to prevent dmaing from/to the stack. 2039 * Allocates a temp buffer to prevent dmaing from/to the stack.
2040 */ 2040 */
2041 int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request, 2041 int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
2042 __u8 requesttype, __u16 value, __u16 index, void *data, 2042 __u8 requesttype, __u16 value, __u16 index, void *data,
2043 __u16 size, int timeout) 2043 __u16 size, int timeout)
2044 { 2044 {
2045 int err; 2045 int err;
2046 void *buf = NULL; 2046 void *buf = NULL;
2047 2047
2048 if (size > 0) { 2048 if (size > 0) {
2049 buf = kmalloc(size, GFP_KERNEL); 2049 buf = kmalloc(size, GFP_KERNEL);
2050 if (!buf) 2050 if (!buf)
2051 return -ENOMEM; 2051 return -ENOMEM;
2052 memcpy(buf, data, size); 2052 memcpy(buf, data, size);
2053 } 2053 }
2054 err = usb_control_msg(dev, pipe, request, requesttype, 2054 err = usb_control_msg(dev, pipe, request, requesttype,
2055 value, index, buf, size, timeout); 2055 value, index, buf, size, timeout);
2056 if (size > 0) { 2056 if (size > 0) {
2057 memcpy(data, buf, size); 2057 memcpy(data, buf, size);
2058 kfree(buf); 2058 kfree(buf);
2059 } 2059 }
2060 return err; 2060 return err;
2061 } 2061 }
2062 2062
2063 2063
2064 /* 2064 /*
2065 * entry point for linux usb interface 2065 * entry point for linux usb interface
2066 */ 2066 */
2067 2067
2068 static int usb_audio_probe(struct usb_interface *intf, 2068 static int usb_audio_probe(struct usb_interface *intf,
2069 const struct usb_device_id *id); 2069 const struct usb_device_id *id);
2070 static void usb_audio_disconnect(struct usb_interface *intf); 2070 static void usb_audio_disconnect(struct usb_interface *intf);
2071 2071
2072 static struct usb_device_id usb_audio_ids [] = { 2072 static struct usb_device_id usb_audio_ids [] = {
2073 #include "usbquirks.h" 2073 #include "usbquirks.h"
2074 { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS), 2074 { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
2075 .bInterfaceClass = USB_CLASS_AUDIO, 2075 .bInterfaceClass = USB_CLASS_AUDIO,
2076 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL }, 2076 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
2077 { } /* Terminating entry */ 2077 { } /* Terminating entry */
2078 }; 2078 };
2079 2079
2080 MODULE_DEVICE_TABLE (usb, usb_audio_ids); 2080 MODULE_DEVICE_TABLE (usb, usb_audio_ids);
2081 2081
2082 static struct usb_driver usb_audio_driver = { 2082 static struct usb_driver usb_audio_driver = {
2083 .name = "snd-usb-audio", 2083 .name = "snd-usb-audio",
2084 .probe = usb_audio_probe, 2084 .probe = usb_audio_probe,
2085 .disconnect = usb_audio_disconnect, 2085 .disconnect = usb_audio_disconnect,
2086 .id_table = usb_audio_ids, 2086 .id_table = usb_audio_ids,
2087 }; 2087 };
2088 2088
2089 2089
2090 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SND_VERBOSE_PROCFS) 2090 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SND_VERBOSE_PROCFS)
2091 2091
2092 /* 2092 /*
2093 * proc interface for list the supported pcm formats 2093 * proc interface for list the supported pcm formats
2094 */ 2094 */
2095 static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer) 2095 static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2096 { 2096 {
2097 struct list_head *p; 2097 struct list_head *p;
2098 static char *sync_types[4] = { 2098 static char *sync_types[4] = {
2099 "NONE", "ASYNC", "ADAPTIVE", "SYNC" 2099 "NONE", "ASYNC", "ADAPTIVE", "SYNC"
2100 }; 2100 };
2101 2101
2102 list_for_each(p, &subs->fmt_list) { 2102 list_for_each(p, &subs->fmt_list) {
2103 struct audioformat *fp; 2103 struct audioformat *fp;
2104 fp = list_entry(p, struct audioformat, list); 2104 fp = list_entry(p, struct audioformat, list);
2105 snd_iprintf(buffer, " Interface %d\n", fp->iface); 2105 snd_iprintf(buffer, " Interface %d\n", fp->iface);
2106 snd_iprintf(buffer, " Altset %d\n", fp->altsetting); 2106 snd_iprintf(buffer, " Altset %d\n", fp->altsetting);
2107 snd_iprintf(buffer, " Format: 0x%x\n", fp->format); 2107 snd_iprintf(buffer, " Format: 0x%x\n", fp->format);
2108 snd_iprintf(buffer, " Channels: %d\n", fp->channels); 2108 snd_iprintf(buffer, " Channels: %d\n", fp->channels);
2109 snd_iprintf(buffer, " Endpoint: %d %s (%s)\n", 2109 snd_iprintf(buffer, " Endpoint: %d %s (%s)\n",
2110 fp->endpoint & USB_ENDPOINT_NUMBER_MASK, 2110 fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
2111 fp->endpoint & USB_DIR_IN ? "IN" : "OUT", 2111 fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
2112 sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]); 2112 sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
2113 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) { 2113 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
2114 snd_iprintf(buffer, " Rates: %d - %d (continuous)\n", 2114 snd_iprintf(buffer, " Rates: %d - %d (continuous)\n",
2115 fp->rate_min, fp->rate_max); 2115 fp->rate_min, fp->rate_max);
2116 } else { 2116 } else {
2117 unsigned int i; 2117 unsigned int i;
2118 snd_iprintf(buffer, " Rates: "); 2118 snd_iprintf(buffer, " Rates: ");
2119 for (i = 0; i < fp->nr_rates; i++) { 2119 for (i = 0; i < fp->nr_rates; i++) {
2120 if (i > 0) 2120 if (i > 0)
2121 snd_iprintf(buffer, ", "); 2121 snd_iprintf(buffer, ", ");
2122 snd_iprintf(buffer, "%d", fp->rate_table[i]); 2122 snd_iprintf(buffer, "%d", fp->rate_table[i]);
2123 } 2123 }
2124 snd_iprintf(buffer, "\n"); 2124 snd_iprintf(buffer, "\n");
2125 } 2125 }
2126 // snd_iprintf(buffer, " Max Packet Size = %d\n", fp->maxpacksize); 2126 // snd_iprintf(buffer, " Max Packet Size = %d\n", fp->maxpacksize);
2127 // snd_iprintf(buffer, " EP Attribute = 0x%x\n", fp->attributes); 2127 // snd_iprintf(buffer, " EP Attribute = 0x%x\n", fp->attributes);
2128 } 2128 }
2129 } 2129 }
2130 2130
2131 static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer) 2131 static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
2132 { 2132 {
2133 if (subs->running) { 2133 if (subs->running) {
2134 unsigned int i; 2134 unsigned int i;
2135 snd_iprintf(buffer, " Status: Running\n"); 2135 snd_iprintf(buffer, " Status: Running\n");
2136 snd_iprintf(buffer, " Interface = %d\n", subs->interface); 2136 snd_iprintf(buffer, " Interface = %d\n", subs->interface);
2137 snd_iprintf(buffer, " Altset = %d\n", subs->format); 2137 snd_iprintf(buffer, " Altset = %d\n", subs->format);
2138 snd_iprintf(buffer, " URBs = %d [ ", subs->nurbs); 2138 snd_iprintf(buffer, " URBs = %d [ ", subs->nurbs);
2139 for (i = 0; i < subs->nurbs; i++) 2139 for (i = 0; i < subs->nurbs; i++)
2140 snd_iprintf(buffer, "%d ", subs->dataurb[i].packets); 2140 snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
2141 snd_iprintf(buffer, "]\n"); 2141 snd_iprintf(buffer, "]\n");
2142 snd_iprintf(buffer, " Packet Size = %d\n", subs->curpacksize); 2142 snd_iprintf(buffer, " Packet Size = %d\n", subs->curpacksize);
2143 snd_iprintf(buffer, " Momentary freq = %u Hz (%#x.%04x)\n", 2143 snd_iprintf(buffer, " Momentary freq = %u Hz (%#x.%04x)\n",
2144 snd_usb_get_speed(subs->dev) == USB_SPEED_FULL 2144 snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
2145 ? get_full_speed_hz(subs->freqm) 2145 ? get_full_speed_hz(subs->freqm)
2146 : get_high_speed_hz(subs->freqm), 2146 : get_high_speed_hz(subs->freqm),
2147 subs->freqm >> 16, subs->freqm & 0xffff); 2147 subs->freqm >> 16, subs->freqm & 0xffff);
2148 } else { 2148 } else {
2149 snd_iprintf(buffer, " Status: Stop\n"); 2149 snd_iprintf(buffer, " Status: Stop\n");
2150 } 2150 }
2151 } 2151 }
2152 2152
2153 static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) 2153 static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
2154 { 2154 {
2155 struct snd_usb_stream *stream = entry->private_data; 2155 struct snd_usb_stream *stream = entry->private_data;
2156 2156
2157 snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name); 2157 snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
2158 2158
2159 if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) { 2159 if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
2160 snd_iprintf(buffer, "\nPlayback:\n"); 2160 snd_iprintf(buffer, "\nPlayback:\n");
2161 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer); 2161 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2162 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer); 2162 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2163 } 2163 }
2164 if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) { 2164 if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
2165 snd_iprintf(buffer, "\nCapture:\n"); 2165 snd_iprintf(buffer, "\nCapture:\n");
2166 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer); 2166 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2167 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer); 2167 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2168 } 2168 }
2169 } 2169 }
2170 2170
2171 static void proc_pcm_format_add(struct snd_usb_stream *stream) 2171 static void proc_pcm_format_add(struct snd_usb_stream *stream)
2172 { 2172 {
2173 struct snd_info_entry *entry; 2173 struct snd_info_entry *entry;
2174 char name[32]; 2174 char name[32];
2175 struct snd_card *card = stream->chip->card; 2175 struct snd_card *card = stream->chip->card;
2176 2176
2177 sprintf(name, "stream%d", stream->pcm_index); 2177 sprintf(name, "stream%d", stream->pcm_index);
2178 if (! snd_card_proc_new(card, name, &entry)) 2178 if (! snd_card_proc_new(card, name, &entry))
2179 snd_info_set_text_ops(entry, stream, proc_pcm_format_read); 2179 snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
2180 } 2180 }
2181 2181
2182 #else 2182 #else
2183 2183
2184 static inline void proc_pcm_format_add(struct snd_usb_stream *stream) 2184 static inline void proc_pcm_format_add(struct snd_usb_stream *stream)
2185 { 2185 {
2186 } 2186 }
2187 2187
2188 #endif 2188 #endif
2189 2189
2190 /* 2190 /*
2191 * initialize the substream instance. 2191 * initialize the substream instance.
2192 */ 2192 */
2193 2193
2194 static void init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp) 2194 static void init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp)
2195 { 2195 {
2196 struct snd_usb_substream *subs = &as->substream[stream]; 2196 struct snd_usb_substream *subs = &as->substream[stream];
2197 2197
2198 INIT_LIST_HEAD(&subs->fmt_list); 2198 INIT_LIST_HEAD(&subs->fmt_list);
2199 spin_lock_init(&subs->lock); 2199 spin_lock_init(&subs->lock);
2200 2200
2201 subs->stream = as; 2201 subs->stream = as;
2202 subs->direction = stream; 2202 subs->direction = stream;
2203 subs->dev = as->chip->dev; 2203 subs->dev = as->chip->dev;
2204 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) 2204 if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
2205 subs->ops = audio_urb_ops[stream]; 2205 subs->ops = audio_urb_ops[stream];
2206 else 2206 else
2207 subs->ops = audio_urb_ops_high_speed[stream]; 2207 subs->ops = audio_urb_ops_high_speed[stream];
2208 snd_pcm_set_ops(as->pcm, stream, 2208 snd_pcm_set_ops(as->pcm, stream,
2209 stream == SNDRV_PCM_STREAM_PLAYBACK ? 2209 stream == SNDRV_PCM_STREAM_PLAYBACK ?
2210 &snd_usb_playback_ops : &snd_usb_capture_ops); 2210 &snd_usb_playback_ops : &snd_usb_capture_ops);
2211 2211
2212 list_add_tail(&fp->list, &subs->fmt_list); 2212 list_add_tail(&fp->list, &subs->fmt_list);
2213 subs->formats |= 1ULL << fp->format; 2213 subs->formats |= 1ULL << fp->format;
2214 subs->endpoint = fp->endpoint; 2214 subs->endpoint = fp->endpoint;
2215 subs->num_formats++; 2215 subs->num_formats++;
2216 subs->fmt_type = fp->fmt_type; 2216 subs->fmt_type = fp->fmt_type;
2217 } 2217 }
2218 2218
2219 2219
2220 /* 2220 /*
2221 * free a substream 2221 * free a substream
2222 */ 2222 */
2223 static void free_substream(struct snd_usb_substream *subs) 2223 static void free_substream(struct snd_usb_substream *subs)
2224 { 2224 {
2225 struct list_head *p, *n; 2225 struct list_head *p, *n;
2226 2226
2227 if (! subs->num_formats) 2227 if (! subs->num_formats)
2228 return; /* not initialized */ 2228 return; /* not initialized */
2229 list_for_each_safe(p, n, &subs->fmt_list) { 2229 list_for_each_safe(p, n, &subs->fmt_list) {
2230 struct audioformat *fp = list_entry(p, struct audioformat, list); 2230 struct audioformat *fp = list_entry(p, struct audioformat, list);
2231 kfree(fp->rate_table); 2231 kfree(fp->rate_table);
2232 kfree(fp); 2232 kfree(fp);
2233 } 2233 }
2234 } 2234 }
2235 2235
2236 2236
2237 /* 2237 /*
2238 * free a usb stream instance 2238 * free a usb stream instance
2239 */ 2239 */
2240 static void snd_usb_audio_stream_free(struct snd_usb_stream *stream) 2240 static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
2241 { 2241 {
2242 free_substream(&stream->substream[0]); 2242 free_substream(&stream->substream[0]);
2243 free_substream(&stream->substream[1]); 2243 free_substream(&stream->substream[1]);
2244 list_del(&stream->list); 2244 list_del(&stream->list);
2245 kfree(stream); 2245 kfree(stream);
2246 } 2246 }
2247 2247
2248 static void snd_usb_audio_pcm_free(struct snd_pcm *pcm) 2248 static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
2249 { 2249 {
2250 struct snd_usb_stream *stream = pcm->private_data; 2250 struct snd_usb_stream *stream = pcm->private_data;
2251 if (stream) { 2251 if (stream) {
2252 stream->pcm = NULL; 2252 stream->pcm = NULL;
2253 snd_usb_audio_stream_free(stream); 2253 snd_usb_audio_stream_free(stream);
2254 } 2254 }
2255 } 2255 }
2256 2256
2257 2257
2258 /* 2258 /*
2259 * add this endpoint to the chip instance. 2259 * add this endpoint to the chip instance.
2260 * if a stream with the same endpoint already exists, append to it. 2260 * if a stream with the same endpoint already exists, append to it.
2261 * if not, create a new pcm stream. 2261 * if not, create a new pcm stream.
2262 */ 2262 */
2263 static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp) 2263 static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp)
2264 { 2264 {
2265 struct list_head *p; 2265 struct list_head *p;
2266 struct snd_usb_stream *as; 2266 struct snd_usb_stream *as;
2267 struct snd_usb_substream *subs; 2267 struct snd_usb_substream *subs;
2268 struct snd_pcm *pcm; 2268 struct snd_pcm *pcm;
2269 int err; 2269 int err;
2270 2270
2271 list_for_each(p, &chip->pcm_list) { 2271 list_for_each(p, &chip->pcm_list) {
2272 as = list_entry(p, struct snd_usb_stream, list); 2272 as = list_entry(p, struct snd_usb_stream, list);
2273 if (as->fmt_type != fp->fmt_type) 2273 if (as->fmt_type != fp->fmt_type)
2274 continue; 2274 continue;
2275 subs = &as->substream[stream]; 2275 subs = &as->substream[stream];
2276 if (! subs->endpoint) 2276 if (! subs->endpoint)
2277 continue; 2277 continue;
2278 if (subs->endpoint == fp->endpoint) { 2278 if (subs->endpoint == fp->endpoint) {
2279 list_add_tail(&fp->list, &subs->fmt_list); 2279 list_add_tail(&fp->list, &subs->fmt_list);
2280 subs->num_formats++; 2280 subs->num_formats++;
2281 subs->formats |= 1ULL << fp->format; 2281 subs->formats |= 1ULL << fp->format;
2282 return 0; 2282 return 0;
2283 } 2283 }
2284 } 2284 }
2285 /* look for an empty stream */ 2285 /* look for an empty stream */
2286 list_for_each(p, &chip->pcm_list) { 2286 list_for_each(p, &chip->pcm_list) {
2287 as = list_entry(p, struct snd_usb_stream, list); 2287 as = list_entry(p, struct snd_usb_stream, list);
2288 if (as->fmt_type != fp->fmt_type) 2288 if (as->fmt_type != fp->fmt_type)
2289 continue; 2289 continue;
2290 subs = &as->substream[stream]; 2290 subs = &as->substream[stream];
2291 if (subs->endpoint) 2291 if (subs->endpoint)
2292 continue; 2292 continue;
2293 err = snd_pcm_new_stream(as->pcm, stream, 1); 2293 err = snd_pcm_new_stream(as->pcm, stream, 1);
2294 if (err < 0) 2294 if (err < 0)
2295 return err; 2295 return err;
2296 init_substream(as, stream, fp); 2296 init_substream(as, stream, fp);
2297 return 0; 2297 return 0;
2298 } 2298 }
2299 2299
2300 /* create a new pcm */ 2300 /* create a new pcm */
2301 as = kzalloc(sizeof(*as), GFP_KERNEL); 2301 as = kzalloc(sizeof(*as), GFP_KERNEL);
2302 if (! as) 2302 if (! as)
2303 return -ENOMEM; 2303 return -ENOMEM;
2304 as->pcm_index = chip->pcm_devs; 2304 as->pcm_index = chip->pcm_devs;
2305 as->chip = chip; 2305 as->chip = chip;
2306 as->fmt_type = fp->fmt_type; 2306 as->fmt_type = fp->fmt_type;
2307 err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs, 2307 err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
2308 stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0, 2308 stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
2309 stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1, 2309 stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
2310 &pcm); 2310 &pcm);
2311 if (err < 0) { 2311 if (err < 0) {
2312 kfree(as); 2312 kfree(as);
2313 return err; 2313 return err;
2314 } 2314 }
2315 as->pcm = pcm; 2315 as->pcm = pcm;
2316 pcm->private_data = as; 2316 pcm->private_data = as;
2317 pcm->private_free = snd_usb_audio_pcm_free; 2317 pcm->private_free = snd_usb_audio_pcm_free;
2318 pcm->info_flags = 0; 2318 pcm->info_flags = 0;
2319 if (chip->pcm_devs > 0) 2319 if (chip->pcm_devs > 0)
2320 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs); 2320 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
2321 else 2321 else
2322 strcpy(pcm->name, "USB Audio"); 2322 strcpy(pcm->name, "USB Audio");
2323 2323
2324 init_substream(as, stream, fp); 2324 init_substream(as, stream, fp);
2325 2325
2326 list_add(&as->list, &chip->pcm_list); 2326 list_add(&as->list, &chip->pcm_list);
2327 chip->pcm_devs++; 2327 chip->pcm_devs++;
2328 2328
2329 proc_pcm_format_add(as); 2329 proc_pcm_format_add(as);
2330 2330
2331 return 0; 2331 return 0;
2332 } 2332 }
2333 2333
2334 2334
2335 /* 2335 /*
2336 * check if the device uses big-endian samples 2336 * check if the device uses big-endian samples
2337 */ 2337 */
2338 static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp) 2338 static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
2339 { 2339 {
2340 switch (chip->usb_id) { 2340 switch (chip->usb_id) {
2341 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */ 2341 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
2342 if (fp->endpoint & USB_DIR_IN) 2342 if (fp->endpoint & USB_DIR_IN)
2343 return 1; 2343 return 1;
2344 break; 2344 break;
2345 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ 2345 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2346 return 1; 2346 return 1;
2347 } 2347 }
2348 return 0; 2348 return 0;
2349 } 2349 }
2350 2350
2351 /* 2351 /*
2352 * parse the audio format type I descriptor 2352 * parse the audio format type I descriptor
2353 * and returns the corresponding pcm format 2353 * and returns the corresponding pcm format
2354 * 2354 *
2355 * @dev: usb device 2355 * @dev: usb device
2356 * @fp: audioformat record 2356 * @fp: audioformat record
2357 * @format: the format tag (wFormatTag) 2357 * @format: the format tag (wFormatTag)
2358 * @fmt: the format type descriptor 2358 * @fmt: the format type descriptor
2359 */ 2359 */
2360 static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp, 2360 static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp,
2361 int format, unsigned char *fmt) 2361 int format, unsigned char *fmt)
2362 { 2362 {
2363 int pcm_format; 2363 int pcm_format;
2364 int sample_width, sample_bytes; 2364 int sample_width, sample_bytes;
2365 2365
2366 /* FIXME: correct endianess and sign? */ 2366 /* FIXME: correct endianess and sign? */
2367 pcm_format = -1; 2367 pcm_format = -1;
2368 sample_width = fmt[6]; 2368 sample_width = fmt[6];
2369 sample_bytes = fmt[5]; 2369 sample_bytes = fmt[5];
2370 switch (format) { 2370 switch (format) {
2371 case 0: /* some devices don't define this correctly... */ 2371 case 0: /* some devices don't define this correctly... */
2372 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n", 2372 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
2373 chip->dev->devnum, fp->iface, fp->altsetting); 2373 chip->dev->devnum, fp->iface, fp->altsetting);
2374 /* fall-through */ 2374 /* fall-through */
2375 case USB_AUDIO_FORMAT_PCM: 2375 case USB_AUDIO_FORMAT_PCM:
2376 if (sample_width > sample_bytes * 8) { 2376 if (sample_width > sample_bytes * 8) {
2377 snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n", 2377 snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
2378 chip->dev->devnum, fp->iface, fp->altsetting, 2378 chip->dev->devnum, fp->iface, fp->altsetting,
2379 sample_width, sample_bytes); 2379 sample_width, sample_bytes);
2380 } 2380 }
2381 /* check the format byte size */ 2381 /* check the format byte size */
2382 switch (fmt[5]) { 2382 switch (fmt[5]) {
2383 case 1: 2383 case 1:
2384 pcm_format = SNDRV_PCM_FORMAT_S8; 2384 pcm_format = SNDRV_PCM_FORMAT_S8;
2385 break; 2385 break;
2386 case 2: 2386 case 2:
2387 if (is_big_endian_format(chip, fp)) 2387 if (is_big_endian_format(chip, fp))
2388 pcm_format = SNDRV_PCM_FORMAT_S16_BE; /* grrr, big endian!! */ 2388 pcm_format = SNDRV_PCM_FORMAT_S16_BE; /* grrr, big endian!! */
2389 else 2389 else
2390 pcm_format = SNDRV_PCM_FORMAT_S16_LE; 2390 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2391 break; 2391 break;
2392 case 3: 2392 case 3:
2393 if (is_big_endian_format(chip, fp)) 2393 if (is_big_endian_format(chip, fp))
2394 pcm_format = SNDRV_PCM_FORMAT_S24_3BE; /* grrr, big endian!! */ 2394 pcm_format = SNDRV_PCM_FORMAT_S24_3BE; /* grrr, big endian!! */
2395 else 2395 else
2396 pcm_format = SNDRV_PCM_FORMAT_S24_3LE; 2396 pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
2397 break; 2397 break;
2398 case 4: 2398 case 4:
2399 pcm_format = SNDRV_PCM_FORMAT_S32_LE; 2399 pcm_format = SNDRV_PCM_FORMAT_S32_LE;
2400 break; 2400 break;
2401 default: 2401 default:
2402 snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n", 2402 snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
2403 chip->dev->devnum, fp->iface, 2403 chip->dev->devnum, fp->iface,
2404 fp->altsetting, sample_width, sample_bytes); 2404 fp->altsetting, sample_width, sample_bytes);
2405 break; 2405 break;
2406 } 2406 }
2407 break; 2407 break;
2408 case USB_AUDIO_FORMAT_PCM8: 2408 case USB_AUDIO_FORMAT_PCM8:
2409 /* Dallas DS4201 workaround */ 2409 /* Dallas DS4201 workaround */
2410 if (chip->usb_id == USB_ID(0x04fa, 0x4201)) 2410 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2411 pcm_format = SNDRV_PCM_FORMAT_S8; 2411 pcm_format = SNDRV_PCM_FORMAT_S8;
2412 else 2412 else
2413 pcm_format = SNDRV_PCM_FORMAT_U8; 2413 pcm_format = SNDRV_PCM_FORMAT_U8;
2414 break; 2414 break;
2415 case USB_AUDIO_FORMAT_IEEE_FLOAT: 2415 case USB_AUDIO_FORMAT_IEEE_FLOAT:
2416 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE; 2416 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
2417 break; 2417 break;
2418 case USB_AUDIO_FORMAT_ALAW: 2418 case USB_AUDIO_FORMAT_ALAW:
2419 pcm_format = SNDRV_PCM_FORMAT_A_LAW; 2419 pcm_format = SNDRV_PCM_FORMAT_A_LAW;
2420 break; 2420 break;
2421 case USB_AUDIO_FORMAT_MU_LAW: 2421 case USB_AUDIO_FORMAT_MU_LAW:
2422 pcm_format = SNDRV_PCM_FORMAT_MU_LAW; 2422 pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
2423 break; 2423 break;
2424 default: 2424 default:
2425 snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n", 2425 snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n",
2426 chip->dev->devnum, fp->iface, fp->altsetting, format); 2426 chip->dev->devnum, fp->iface, fp->altsetting, format);
2427 break; 2427 break;
2428 } 2428 }
2429 return pcm_format; 2429 return pcm_format;
2430 } 2430 }
2431 2431
2432 2432
2433 /* 2433 /*
2434 * parse the format descriptor and stores the possible sample rates 2434 * parse the format descriptor and stores the possible sample rates
2435 * on the audioformat table. 2435 * on the audioformat table.
2436 * 2436 *
2437 * @dev: usb device 2437 * @dev: usb device
2438 * @fp: audioformat record 2438 * @fp: audioformat record
2439 * @fmt: the format descriptor 2439 * @fmt: the format descriptor
2440 * @offset: the start offset of descriptor pointing the rate type 2440 * @offset: the start offset of descriptor pointing the rate type
2441 * (7 for type I and II, 8 for type II) 2441 * (7 for type I and II, 8 for type II)
2442 */ 2442 */
2443 static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp, 2443 static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp,
2444 unsigned char *fmt, int offset) 2444 unsigned char *fmt, int offset)
2445 { 2445 {
2446 int nr_rates = fmt[offset]; 2446 int nr_rates = fmt[offset];
2447 int found; 2447 int found;
2448 if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) { 2448 if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
2449 snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n", 2449 snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2450 chip->dev->devnum, fp->iface, fp->altsetting); 2450 chip->dev->devnum, fp->iface, fp->altsetting);
2451 return -1; 2451 return -1;
2452 } 2452 }
2453 2453
2454 if (nr_rates) { 2454 if (nr_rates) {
2455 /* 2455 /*
2456 * build the rate table and bitmap flags 2456 * build the rate table and bitmap flags
2457 */ 2457 */
2458 int r, idx, c; 2458 int r, idx, c;
2459 /* this table corresponds to the SNDRV_PCM_RATE_XXX bit */ 2459 /* this table corresponds to the SNDRV_PCM_RATE_XXX bit */
2460 static unsigned int conv_rates[] = { 2460 static unsigned int conv_rates[] = {
2461 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 2461 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
2462 64000, 88200, 96000, 176400, 192000 2462 64000, 88200, 96000, 176400, 192000
2463 }; 2463 };
2464 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL); 2464 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
2465 if (fp->rate_table == NULL) { 2465 if (fp->rate_table == NULL) {
2466 snd_printk(KERN_ERR "cannot malloc\n"); 2466 snd_printk(KERN_ERR "cannot malloc\n");
2467 return -1; 2467 return -1;
2468 } 2468 }
2469 2469
2470 fp->needs_knot = 0; 2470 fp->needs_knot = 0;
2471 fp->nr_rates = nr_rates; 2471 fp->nr_rates = nr_rates;
2472 fp->rate_min = fp->rate_max = combine_triple(&fmt[8]); 2472 fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
2473 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) { 2473 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
2474 unsigned int rate = fp->rate_table[r] = combine_triple(&fmt[idx]); 2474 unsigned int rate = fp->rate_table[r] = combine_triple(&fmt[idx]);
2475 if (rate < fp->rate_min) 2475 if (rate < fp->rate_min)
2476 fp->rate_min = rate; 2476 fp->rate_min = rate;
2477 else if (rate > fp->rate_max) 2477 else if (rate > fp->rate_max)
2478 fp->rate_max = rate; 2478 fp->rate_max = rate;
2479 found = 0; 2479 found = 0;
2480 for (c = 0; c < (int)ARRAY_SIZE(conv_rates); c++) { 2480 for (c = 0; c < (int)ARRAY_SIZE(conv_rates); c++) {
2481 if (rate == conv_rates[c]) { 2481 if (rate == conv_rates[c]) {
2482 found = 1; 2482 found = 1;
2483 fp->rates |= (1 << c); 2483 fp->rates |= (1 << c);
2484 break; 2484 break;
2485 } 2485 }
2486 } 2486 }
2487 if (!found) 2487 if (!found)
2488 fp->needs_knot = 1; 2488 fp->needs_knot = 1;
2489 } 2489 }
2490 if (fp->needs_knot) 2490 if (fp->needs_knot)
2491 fp->rates |= SNDRV_PCM_RATE_KNOT; 2491 fp->rates |= SNDRV_PCM_RATE_KNOT;
2492 } else { 2492 } else {
2493 /* continuous rates */ 2493 /* continuous rates */
2494 fp->rates = SNDRV_PCM_RATE_CONTINUOUS; 2494 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
2495 fp->rate_min = combine_triple(&fmt[offset + 1]); 2495 fp->rate_min = combine_triple(&fmt[offset + 1]);
2496 fp->rate_max = combine_triple(&fmt[offset + 4]); 2496 fp->rate_max = combine_triple(&fmt[offset + 4]);
2497 } 2497 }
2498 return 0; 2498 return 0;
2499 } 2499 }
2500 2500
2501 /* 2501 /*
2502 * parse the format type I and III descriptors 2502 * parse the format type I and III descriptors
2503 */ 2503 */
2504 static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp, 2504 static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp,
2505 int format, unsigned char *fmt) 2505 int format, unsigned char *fmt)
2506 { 2506 {
2507 int pcm_format; 2507 int pcm_format;
2508 2508
2509 if (fmt[3] == USB_FORMAT_TYPE_III) { 2509 if (fmt[3] == USB_FORMAT_TYPE_III) {
2510 /* FIXME: the format type is really IECxxx 2510 /* FIXME: the format type is really IECxxx
2511 * but we give normal PCM format to get the existing 2511 * but we give normal PCM format to get the existing
2512 * apps working... 2512 * apps working...
2513 */ 2513 */
2514 pcm_format = SNDRV_PCM_FORMAT_S16_LE; 2514 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2515 } else { 2515 } else {
2516 pcm_format = parse_audio_format_i_type(chip, fp, format, fmt); 2516 pcm_format = parse_audio_format_i_type(chip, fp, format, fmt);
2517 if (pcm_format < 0) 2517 if (pcm_format < 0)
2518 return -1; 2518 return -1;
2519 } 2519 }
2520 fp->format = pcm_format; 2520 fp->format = pcm_format;
2521 fp->channels = fmt[4]; 2521 fp->channels = fmt[4];
2522 if (fp->channels < 1) { 2522 if (fp->channels < 1) {
2523 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n", 2523 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
2524 chip->dev->devnum, fp->iface, fp->altsetting, fp->channels); 2524 chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
2525 return -1; 2525 return -1;
2526 } 2526 }
2527 return parse_audio_format_rates(chip, fp, fmt, 7); 2527 return parse_audio_format_rates(chip, fp, fmt, 7);
2528 } 2528 }
2529 2529
2530 /* 2530 /*
2531 * prase the format type II descriptor 2531 * prase the format type II descriptor
2532 */ 2532 */
2533 static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp, 2533 static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp,
2534 int format, unsigned char *fmt) 2534 int format, unsigned char *fmt)
2535 { 2535 {
2536 int brate, framesize; 2536 int brate, framesize;
2537 switch (format) { 2537 switch (format) {
2538 case USB_AUDIO_FORMAT_AC3: 2538 case USB_AUDIO_FORMAT_AC3:
2539 /* FIXME: there is no AC3 format defined yet */ 2539 /* FIXME: there is no AC3 format defined yet */
2540 // fp->format = SNDRV_PCM_FORMAT_AC3; 2540 // fp->format = SNDRV_PCM_FORMAT_AC3;
2541 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */ 2541 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
2542 break; 2542 break;
2543 case USB_AUDIO_FORMAT_MPEG: 2543 case USB_AUDIO_FORMAT_MPEG:
2544 fp->format = SNDRV_PCM_FORMAT_MPEG; 2544 fp->format = SNDRV_PCM_FORMAT_MPEG;
2545 break; 2545 break;
2546 default: 2546 default:
2547 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag 0x%x is detected. processed as MPEG.\n", 2547 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag 0x%x is detected. processed as MPEG.\n",
2548 chip->dev->devnum, fp->iface, fp->altsetting, format); 2548 chip->dev->devnum, fp->iface, fp->altsetting, format);
2549 fp->format = SNDRV_PCM_FORMAT_MPEG; 2549 fp->format = SNDRV_PCM_FORMAT_MPEG;
2550 break; 2550 break;
2551 } 2551 }
2552 fp->channels = 1; 2552 fp->channels = 1;
2553 brate = combine_word(&fmt[4]); /* fmt[4,5] : wMaxBitRate (in kbps) */ 2553 brate = combine_word(&fmt[4]); /* fmt[4,5] : wMaxBitRate (in kbps) */
2554 framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */ 2554 framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */
2555 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize); 2555 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
2556 fp->frame_size = framesize; 2556 fp->frame_size = framesize;
2557 return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */ 2557 return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
2558 } 2558 }
2559 2559
2560 static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp, 2560 static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
2561 int format, unsigned char *fmt, int stream) 2561 int format, unsigned char *fmt, int stream)
2562 { 2562 {
2563 int err; 2563 int err;
2564 2564
2565 switch (fmt[3]) { 2565 switch (fmt[3]) {
2566 case USB_FORMAT_TYPE_I: 2566 case USB_FORMAT_TYPE_I:
2567 case USB_FORMAT_TYPE_III: 2567 case USB_FORMAT_TYPE_III:
2568 err = parse_audio_format_i(chip, fp, format, fmt); 2568 err = parse_audio_format_i(chip, fp, format, fmt);
2569 break; 2569 break;
2570 case USB_FORMAT_TYPE_II: 2570 case USB_FORMAT_TYPE_II:
2571 err = parse_audio_format_ii(chip, fp, format, fmt); 2571 err = parse_audio_format_ii(chip, fp, format, fmt);
2572 break; 2572 break;
2573 default: 2573 default:
2574 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n", 2574 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
2575 chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]); 2575 chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
2576 return -1; 2576 return -1;
2577 } 2577 }
2578 fp->fmt_type = fmt[3]; 2578 fp->fmt_type = fmt[3];
2579 if (err < 0) 2579 if (err < 0)
2580 return err; 2580 return err;
2581 #if 1 2581 #if 1
2582 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */ 2582 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
2583 /* extigy apparently supports sample rates other than 48k 2583 /* extigy apparently supports sample rates other than 48k
2584 * but not in ordinary way. so we enable only 48k atm. 2584 * but not in ordinary way. so we enable only 48k atm.
2585 */ 2585 */
2586 if (chip->usb_id == USB_ID(0x041e, 0x3000) || 2586 if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
2587 chip->usb_id == USB_ID(0x041e, 0x3020) || 2587 chip->usb_id == USB_ID(0x041e, 0x3020) ||
2588 chip->usb_id == USB_ID(0x041e, 0x3061)) { 2588 chip->usb_id == USB_ID(0x041e, 0x3061)) {
2589 if (fmt[3] == USB_FORMAT_TYPE_I && 2589 if (fmt[3] == USB_FORMAT_TYPE_I &&
2590 fp->rates != SNDRV_PCM_RATE_48000 && 2590 fp->rates != SNDRV_PCM_RATE_48000 &&
2591 fp->rates != SNDRV_PCM_RATE_96000) 2591 fp->rates != SNDRV_PCM_RATE_96000)
2592 return -1; 2592 return -1;
2593 } 2593 }
2594 #endif 2594 #endif
2595 return 0; 2595 return 0;
2596 } 2596 }
2597 2597
2598 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip, 2598 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
2599 int iface, int altno); 2599 int iface, int altno);
2600 static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no) 2600 static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
2601 { 2601 {
2602 struct usb_device *dev; 2602 struct usb_device *dev;
2603 struct usb_interface *iface; 2603 struct usb_interface *iface;
2604 struct usb_host_interface *alts; 2604 struct usb_host_interface *alts;
2605 struct usb_interface_descriptor *altsd; 2605 struct usb_interface_descriptor *altsd;
2606 int i, altno, err, stream; 2606 int i, altno, err, stream;
2607 int format; 2607 int format;
2608 struct audioformat *fp; 2608 struct audioformat *fp;
2609 unsigned char *fmt, *csep; 2609 unsigned char *fmt, *csep;
2610 2610
2611 dev = chip->dev; 2611 dev = chip->dev;
2612 2612
2613 /* parse the interface's altsettings */ 2613 /* parse the interface's altsettings */
2614 iface = usb_ifnum_to_if(dev, iface_no); 2614 iface = usb_ifnum_to_if(dev, iface_no);
2615 for (i = 0; i < iface->num_altsetting; i++) { 2615 for (i = 0; i < iface->num_altsetting; i++) {
2616 alts = &iface->altsetting[i]; 2616 alts = &iface->altsetting[i];
2617 altsd = get_iface_desc(alts); 2617 altsd = get_iface_desc(alts);
2618 /* skip invalid one */ 2618 /* skip invalid one */
2619 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO && 2619 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2620 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || 2620 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2621 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING && 2621 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING &&
2622 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) || 2622 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
2623 altsd->bNumEndpoints < 1 || 2623 altsd->bNumEndpoints < 1 ||
2624 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0) 2624 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
2625 continue; 2625 continue;
2626 /* must be isochronous */ 2626 /* must be isochronous */
2627 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 2627 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
2628 USB_ENDPOINT_XFER_ISOC) 2628 USB_ENDPOINT_XFER_ISOC)
2629 continue; 2629 continue;
2630 /* check direction */ 2630 /* check direction */
2631 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ? 2631 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
2632 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 2632 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2633 altno = altsd->bAlternateSetting; 2633 altno = altsd->bAlternateSetting;
2634 2634
2635 /* audiophile usb: skip altsets incompatible with device_setup 2635 /* audiophile usb: skip altsets incompatible with device_setup
2636 */ 2636 */
2637 if (chip->usb_id == USB_ID(0x0763, 0x2003) && 2637 if (chip->usb_id == USB_ID(0x0763, 0x2003) &&
2638 audiophile_skip_setting_quirk(chip, iface_no, altno)) 2638 audiophile_skip_setting_quirk(chip, iface_no, altno))
2639 continue; 2639 continue;
2640 2640
2641 /* get audio formats */ 2641 /* get audio formats */
2642 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL); 2642 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL);
2643 if (!fmt) { 2643 if (!fmt) {
2644 snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n", 2644 snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
2645 dev->devnum, iface_no, altno); 2645 dev->devnum, iface_no, altno);
2646 continue; 2646 continue;
2647 } 2647 }
2648 2648
2649 if (fmt[0] < 7) { 2649 if (fmt[0] < 7) {
2650 snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n", 2650 snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
2651 dev->devnum, iface_no, altno); 2651 dev->devnum, iface_no, altno);
2652 continue; 2652 continue;
2653 } 2653 }
2654 2654
2655 format = (fmt[6] << 8) | fmt[5]; /* remember the format value */ 2655 format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
2656 2656
2657 /* get format type */ 2657 /* get format type */
2658 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE); 2658 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE);
2659 if (!fmt) { 2659 if (!fmt) {
2660 snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n", 2660 snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
2661 dev->devnum, iface_no, altno); 2661 dev->devnum, iface_no, altno);
2662 continue; 2662 continue;
2663 } 2663 }
2664 if (fmt[0] < 8) { 2664 if (fmt[0] < 8) {
2665 snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n", 2665 snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2666 dev->devnum, iface_no, altno); 2666 dev->devnum, iface_no, altno);
2667 continue; 2667 continue;
2668 } 2668 }
2669 2669
2670 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT); 2670 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
2671 /* Creamware Noah has this descriptor after the 2nd endpoint */ 2671 /* Creamware Noah has this descriptor after the 2nd endpoint */
2672 if (!csep && altsd->bNumEndpoints >= 2) 2672 if (!csep && altsd->bNumEndpoints >= 2)
2673 csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT); 2673 csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
2674 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) { 2674 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
2675 snd_printk(KERN_WARNING "%d:%u:%d : no or invalid" 2675 snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
2676 " class specific endpoint descriptor\n", 2676 " class specific endpoint descriptor\n",
2677 dev->devnum, iface_no, altno); 2677 dev->devnum, iface_no, altno);
2678 csep = NULL; 2678 csep = NULL;
2679 } 2679 }
2680 2680
2681 fp = kzalloc(sizeof(*fp), GFP_KERNEL); 2681 fp = kzalloc(sizeof(*fp), GFP_KERNEL);
2682 if (! fp) { 2682 if (! fp) {
2683 snd_printk(KERN_ERR "cannot malloc\n"); 2683 snd_printk(KERN_ERR "cannot malloc\n");
2684 return -ENOMEM; 2684 return -ENOMEM;
2685 } 2685 }
2686 2686
2687 fp->iface = iface_no; 2687 fp->iface = iface_no;
2688 fp->altsetting = altno; 2688 fp->altsetting = altno;
2689 fp->altset_idx = i; 2689 fp->altset_idx = i;
2690 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 2690 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2691 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 2691 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2692 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 2692 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2693 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH) 2693 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
2694 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1) 2694 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
2695 * (fp->maxpacksize & 0x7ff); 2695 * (fp->maxpacksize & 0x7ff);
2696 fp->attributes = csep ? csep[3] : 0; 2696 fp->attributes = csep ? csep[3] : 0;
2697 2697
2698 /* some quirks for attributes here */ 2698 /* some quirks for attributes here */
2699 2699
2700 switch (chip->usb_id) { 2700 switch (chip->usb_id) {
2701 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */ 2701 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
2702 /* Optoplay sets the sample rate attribute although 2702 /* Optoplay sets the sample rate attribute although
2703 * it seems not supporting it in fact. 2703 * it seems not supporting it in fact.
2704 */ 2704 */
2705 fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE; 2705 fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE;
2706 break; 2706 break;
2707 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */ 2707 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
2708 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ 2708 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2709 /* doesn't set the sample rate attribute, but supports it */ 2709 /* doesn't set the sample rate attribute, but supports it */
2710 fp->attributes |= EP_CS_ATTR_SAMPLE_RATE; 2710 fp->attributes |= EP_CS_ATTR_SAMPLE_RATE;
2711 break; 2711 break;
2712 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */ 2712 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
2713 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is 2713 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
2714 an older model 77d:223) */ 2714 an older model 77d:223) */
2715 /* 2715 /*
2716 * plantronics headset and Griffin iMic have set adaptive-in 2716 * plantronics headset and Griffin iMic have set adaptive-in
2717 * although it's really not... 2717 * although it's really not...
2718 */ 2718 */
2719 fp->ep_attr &= ~EP_ATTR_MASK; 2719 fp->ep_attr &= ~EP_ATTR_MASK;
2720 if (stream == SNDRV_PCM_STREAM_PLAYBACK) 2720 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2721 fp->ep_attr |= EP_ATTR_ADAPTIVE; 2721 fp->ep_attr |= EP_ATTR_ADAPTIVE;
2722 else 2722 else
2723 fp->ep_attr |= EP_ATTR_SYNC; 2723 fp->ep_attr |= EP_ATTR_SYNC;
2724 break; 2724 break;
2725 } 2725 }
2726 2726
2727 /* ok, let's parse further... */ 2727 /* ok, let's parse further... */
2728 if (parse_audio_format(chip, fp, format, fmt, stream) < 0) { 2728 if (parse_audio_format(chip, fp, format, fmt, stream) < 0) {
2729 kfree(fp->rate_table); 2729 kfree(fp->rate_table);
2730 kfree(fp); 2730 kfree(fp);
2731 continue; 2731 continue;
2732 } 2732 }
2733 2733
2734 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint 0x%x\n", dev->devnum, iface_no, altno, fp->endpoint); 2734 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint 0x%x\n", dev->devnum, iface_no, altno, fp->endpoint);
2735 err = add_audio_endpoint(chip, stream, fp); 2735 err = add_audio_endpoint(chip, stream, fp);
2736 if (err < 0) { 2736 if (err < 0) {
2737 kfree(fp->rate_table); 2737 kfree(fp->rate_table);
2738 kfree(fp); 2738 kfree(fp);
2739 return err; 2739 return err;
2740 } 2740 }
2741 /* try to set the interface... */ 2741 /* try to set the interface... */
2742 usb_set_interface(chip->dev, iface_no, altno); 2742 usb_set_interface(chip->dev, iface_no, altno);
2743 init_usb_pitch(chip->dev, iface_no, alts, fp); 2743 init_usb_pitch(chip->dev, iface_no, alts, fp);
2744 init_usb_sample_rate(chip->dev, iface_no, alts, fp, fp->rate_max); 2744 init_usb_sample_rate(chip->dev, iface_no, alts, fp, fp->rate_max);
2745 } 2745 }
2746 return 0; 2746 return 0;
2747 } 2747 }
2748 2748
2749 2749
2750 /* 2750 /*
2751 * disconnect streams 2751 * disconnect streams
2752 * called from snd_usb_audio_disconnect() 2752 * called from snd_usb_audio_disconnect()
2753 */ 2753 */
2754 static void snd_usb_stream_disconnect(struct list_head *head) 2754 static void snd_usb_stream_disconnect(struct list_head *head)
2755 { 2755 {
2756 int idx; 2756 int idx;
2757 struct snd_usb_stream *as; 2757 struct snd_usb_stream *as;
2758 struct snd_usb_substream *subs; 2758 struct snd_usb_substream *subs;
2759 2759
2760 as = list_entry(head, struct snd_usb_stream, list); 2760 as = list_entry(head, struct snd_usb_stream, list);
2761 for (idx = 0; idx < 2; idx++) { 2761 for (idx = 0; idx < 2; idx++) {
2762 subs = &as->substream[idx]; 2762 subs = &as->substream[idx];
2763 if (!subs->num_formats) 2763 if (!subs->num_formats)
2764 return; 2764 return;
2765 release_substream_urbs(subs, 1); 2765 release_substream_urbs(subs, 1);
2766 subs->interface = -1; 2766 subs->interface = -1;
2767 } 2767 }
2768 } 2768 }
2769 2769
2770 /* 2770 /*
2771 * parse audio control descriptor and create pcm/midi streams 2771 * parse audio control descriptor and create pcm/midi streams
2772 */ 2772 */
2773 static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) 2773 static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
2774 { 2774 {
2775 struct usb_device *dev = chip->dev; 2775 struct usb_device *dev = chip->dev;
2776 struct usb_host_interface *host_iface; 2776 struct usb_host_interface *host_iface;
2777 struct usb_interface *iface; 2777 struct usb_interface *iface;
2778 unsigned char *p1; 2778 unsigned char *p1;
2779 int i, j; 2779 int i, j;
2780 2780
2781 /* find audiocontrol interface */ 2781 /* find audiocontrol interface */
2782 host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0]; 2782 host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
2783 if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) { 2783 if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) {
2784 snd_printk(KERN_ERR "cannot find HEADER\n"); 2784 snd_printk(KERN_ERR "cannot find HEADER\n");
2785 return -EINVAL; 2785 return -EINVAL;
2786 } 2786 }
2787 if (! p1[7] || p1[0] < 8 + p1[7]) { 2787 if (! p1[7] || p1[0] < 8 + p1[7]) {
2788 snd_printk(KERN_ERR "invalid HEADER\n"); 2788 snd_printk(KERN_ERR "invalid HEADER\n");
2789 return -EINVAL; 2789 return -EINVAL;
2790 } 2790 }
2791 2791
2792 /* 2792 /*
2793 * parse all USB audio streaming interfaces 2793 * parse all USB audio streaming interfaces
2794 */ 2794 */
2795 for (i = 0; i < p1[7]; i++) { 2795 for (i = 0; i < p1[7]; i++) {
2796 struct usb_host_interface *alts; 2796 struct usb_host_interface *alts;
2797 struct usb_interface_descriptor *altsd; 2797 struct usb_interface_descriptor *altsd;
2798 j = p1[8 + i]; 2798 j = p1[8 + i];
2799 iface = usb_ifnum_to_if(dev, j); 2799 iface = usb_ifnum_to_if(dev, j);
2800 if (!iface) { 2800 if (!iface) {
2801 snd_printk(KERN_ERR "%d:%u:%d : does not exist\n", 2801 snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
2802 dev->devnum, ctrlif, j); 2802 dev->devnum, ctrlif, j);
2803 continue; 2803 continue;
2804 } 2804 }
2805 if (usb_interface_claimed(iface)) { 2805 if (usb_interface_claimed(iface)) {
2806 snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j); 2806 snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
2807 continue; 2807 continue;
2808 } 2808 }
2809 alts = &iface->altsetting[0]; 2809 alts = &iface->altsetting[0];
2810 altsd = get_iface_desc(alts); 2810 altsd = get_iface_desc(alts);
2811 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO || 2811 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
2812 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) && 2812 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
2813 altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) { 2813 altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
2814 if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) { 2814 if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
2815 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j); 2815 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
2816 continue; 2816 continue;
2817 } 2817 }
2818 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L); 2818 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2819 continue; 2819 continue;
2820 } 2820 }
2821 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO && 2821 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2822 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || 2822 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2823 altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) { 2823 altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
2824 snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass); 2824 snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass);
2825 /* skip non-supported classes */ 2825 /* skip non-supported classes */
2826 continue; 2826 continue;
2827 } 2827 }
2828 if (! parse_audio_endpoints(chip, j)) { 2828 if (! parse_audio_endpoints(chip, j)) {
2829 usb_set_interface(dev, j, 0); /* reset the current interface */ 2829 usb_set_interface(dev, j, 0); /* reset the current interface */
2830 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L); 2830 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2831 } 2831 }
2832 } 2832 }
2833 2833
2834 return 0; 2834 return 0;
2835 } 2835 }
2836 2836
2837 /* 2837 /*
2838 * create a stream for an endpoint/altsetting without proper descriptors 2838 * create a stream for an endpoint/altsetting without proper descriptors
2839 */ 2839 */
2840 static int create_fixed_stream_quirk(struct snd_usb_audio *chip, 2840 static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
2841 struct usb_interface *iface, 2841 struct usb_interface *iface,
2842 const struct snd_usb_audio_quirk *quirk) 2842 const struct snd_usb_audio_quirk *quirk)
2843 { 2843 {
2844 struct audioformat *fp; 2844 struct audioformat *fp;
2845 struct usb_host_interface *alts; 2845 struct usb_host_interface *alts;
2846 int stream, err; 2846 int stream, err;
2847 int *rate_table = NULL; 2847 int *rate_table = NULL;
2848 2848
2849 fp = kmalloc(sizeof(*fp), GFP_KERNEL); 2849 fp = kmalloc(sizeof(*fp), GFP_KERNEL);
2850 if (! fp) { 2850 if (! fp) {
2851 snd_printk(KERN_ERR "cannot malloc\n"); 2851 snd_printk(KERN_ERR "cannot malloc\n");
2852 return -ENOMEM; 2852 return -ENOMEM;
2853 } 2853 }
2854 memcpy(fp, quirk->data, sizeof(*fp)); 2854 memcpy(fp, quirk->data, sizeof(*fp));
2855 if (fp->nr_rates > 0) { 2855 if (fp->nr_rates > 0) {
2856 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL); 2856 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
2857 if (!rate_table) { 2857 if (!rate_table) {
2858 kfree(fp); 2858 kfree(fp);
2859 return -ENOMEM; 2859 return -ENOMEM;
2860 } 2860 }
2861 memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates); 2861 memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates);
2862 fp->rate_table = rate_table; 2862 fp->rate_table = rate_table;
2863 } 2863 }
2864 2864
2865 stream = (fp->endpoint & USB_DIR_IN) 2865 stream = (fp->endpoint & USB_DIR_IN)
2866 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 2866 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2867 err = add_audio_endpoint(chip, stream, fp); 2867 err = add_audio_endpoint(chip, stream, fp);
2868 if (err < 0) { 2868 if (err < 0) {
2869 kfree(fp); 2869 kfree(fp);
2870 kfree(rate_table); 2870 kfree(rate_table);
2871 return err; 2871 return err;
2872 } 2872 }
2873 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber || 2873 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
2874 fp->altset_idx >= iface->num_altsetting) { 2874 fp->altset_idx >= iface->num_altsetting) {
2875 kfree(fp); 2875 kfree(fp);
2876 kfree(rate_table); 2876 kfree(rate_table);
2877 return -EINVAL; 2877 return -EINVAL;
2878 } 2878 }
2879 alts = &iface->altsetting[fp->altset_idx]; 2879 alts = &iface->altsetting[fp->altset_idx];
2880 usb_set_interface(chip->dev, fp->iface, 0); 2880 usb_set_interface(chip->dev, fp->iface, 0);
2881 init_usb_pitch(chip->dev, fp->iface, alts, fp); 2881 init_usb_pitch(chip->dev, fp->iface, alts, fp);
2882 init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max); 2882 init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max);
2883 return 0; 2883 return 0;
2884 } 2884 }
2885 2885
2886 /* 2886 /*
2887 * create a stream for an interface with proper descriptors 2887 * create a stream for an interface with proper descriptors
2888 */ 2888 */
2889 static int create_standard_audio_quirk(struct snd_usb_audio *chip, 2889 static int create_standard_audio_quirk(struct snd_usb_audio *chip,
2890 struct usb_interface *iface, 2890 struct usb_interface *iface,
2891 const struct snd_usb_audio_quirk *quirk) 2891 const struct snd_usb_audio_quirk *quirk)
2892 { 2892 {
2893 struct usb_host_interface *alts; 2893 struct usb_host_interface *alts;
2894 struct usb_interface_descriptor *altsd; 2894 struct usb_interface_descriptor *altsd;
2895 int err; 2895 int err;
2896 2896
2897 alts = &iface->altsetting[0]; 2897 alts = &iface->altsetting[0];
2898 altsd = get_iface_desc(alts); 2898 altsd = get_iface_desc(alts);
2899 err = parse_audio_endpoints(chip, altsd->bInterfaceNumber); 2899 err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
2900 if (err < 0) { 2900 if (err < 0) {
2901 snd_printk(KERN_ERR "cannot setup if %d: error %d\n", 2901 snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
2902 altsd->bInterfaceNumber, err); 2902 altsd->bInterfaceNumber, err);
2903 return err; 2903 return err;
2904 } 2904 }
2905 /* reset the current interface */ 2905 /* reset the current interface */
2906 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0); 2906 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
2907 return 0; 2907 return 0;
2908 } 2908 }
2909 2909
2910 /* 2910 /*
2911 * Create a stream for an Edirol UA-700/UA-25 interface. The only way 2911 * Create a stream for an Edirol UA-700/UA-25 interface. The only way
2912 * to detect the sample rate is by looking at wMaxPacketSize. 2912 * to detect the sample rate is by looking at wMaxPacketSize.
2913 */ 2913 */
2914 static int create_ua700_ua25_quirk(struct snd_usb_audio *chip, 2914 static int create_ua700_ua25_quirk(struct snd_usb_audio *chip,
2915 struct usb_interface *iface, 2915 struct usb_interface *iface,
2916 const struct snd_usb_audio_quirk *quirk) 2916 const struct snd_usb_audio_quirk *quirk)
2917 { 2917 {
2918 static const struct audioformat ua_format = { 2918 static const struct audioformat ua_format = {
2919 .format = SNDRV_PCM_FORMAT_S24_3LE, 2919 .format = SNDRV_PCM_FORMAT_S24_3LE,
2920 .channels = 2, 2920 .channels = 2,
2921 .fmt_type = USB_FORMAT_TYPE_I, 2921 .fmt_type = USB_FORMAT_TYPE_I,
2922 .altsetting = 1, 2922 .altsetting = 1,
2923 .altset_idx = 1, 2923 .altset_idx = 1,
2924 .rates = SNDRV_PCM_RATE_CONTINUOUS, 2924 .rates = SNDRV_PCM_RATE_CONTINUOUS,
2925 }; 2925 };
2926 struct usb_host_interface *alts; 2926 struct usb_host_interface *alts;
2927 struct usb_interface_descriptor *altsd; 2927 struct usb_interface_descriptor *altsd;
2928 struct audioformat *fp; 2928 struct audioformat *fp;
2929 int stream, err; 2929 int stream, err;
2930 2930
2931 /* both PCM and MIDI interfaces have 2 altsettings */ 2931 /* both PCM and MIDI interfaces have 2 altsettings */
2932 if (iface->num_altsetting != 2) 2932 if (iface->num_altsetting != 2)
2933 return -ENXIO; 2933 return -ENXIO;
2934 alts = &iface->altsetting[1]; 2934 alts = &iface->altsetting[1];
2935 altsd = get_iface_desc(alts); 2935 altsd = get_iface_desc(alts);
2936 2936
2937 if (altsd->bNumEndpoints == 2) { 2937 if (altsd->bNumEndpoints == 2) {
2938 static const struct snd_usb_midi_endpoint_info ua700_ep = { 2938 static const struct snd_usb_midi_endpoint_info ua700_ep = {
2939 .out_cables = 0x0003, 2939 .out_cables = 0x0003,
2940 .in_cables = 0x0003 2940 .in_cables = 0x0003
2941 }; 2941 };
2942 static const struct snd_usb_audio_quirk ua700_quirk = { 2942 static const struct snd_usb_audio_quirk ua700_quirk = {
2943 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2943 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2944 .data = &ua700_ep 2944 .data = &ua700_ep
2945 }; 2945 };
2946 static const struct snd_usb_midi_endpoint_info ua25_ep = { 2946 static const struct snd_usb_midi_endpoint_info ua25_ep = {
2947 .out_cables = 0x0001, 2947 .out_cables = 0x0001,
2948 .in_cables = 0x0001 2948 .in_cables = 0x0001
2949 }; 2949 };
2950 static const struct snd_usb_audio_quirk ua25_quirk = { 2950 static const struct snd_usb_audio_quirk ua25_quirk = {
2951 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2951 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2952 .data = &ua25_ep 2952 .data = &ua25_ep
2953 }; 2953 };
2954 if (chip->usb_id == USB_ID(0x0582, 0x002b)) 2954 if (chip->usb_id == USB_ID(0x0582, 0x002b))
2955 return snd_usb_create_midi_interface(chip, iface, 2955 return snd_usb_create_midi_interface(chip, iface,
2956 &ua700_quirk); 2956 &ua700_quirk);
2957 else 2957 else
2958 return snd_usb_create_midi_interface(chip, iface, 2958 return snd_usb_create_midi_interface(chip, iface,
2959 &ua25_quirk); 2959 &ua25_quirk);
2960 } 2960 }
2961 2961
2962 if (altsd->bNumEndpoints != 1) 2962 if (altsd->bNumEndpoints != 1)
2963 return -ENXIO; 2963 return -ENXIO;
2964 2964
2965 fp = kmalloc(sizeof(*fp), GFP_KERNEL); 2965 fp = kmalloc(sizeof(*fp), GFP_KERNEL);
2966 if (!fp) 2966 if (!fp)
2967 return -ENOMEM; 2967 return -ENOMEM;
2968 memcpy(fp, &ua_format, sizeof(*fp)); 2968 memcpy(fp, &ua_format, sizeof(*fp));
2969 2969
2970 fp->iface = altsd->bInterfaceNumber; 2970 fp->iface = altsd->bInterfaceNumber;
2971 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 2971 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2972 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 2972 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2973 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 2973 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2974 2974
2975 switch (fp->maxpacksize) { 2975 switch (fp->maxpacksize) {
2976 case 0x120: 2976 case 0x120:
2977 fp->rate_max = fp->rate_min = 44100; 2977 fp->rate_max = fp->rate_min = 44100;
2978 break; 2978 break;
2979 case 0x138: 2979 case 0x138:
2980 case 0x140: 2980 case 0x140:
2981 fp->rate_max = fp->rate_min = 48000; 2981 fp->rate_max = fp->rate_min = 48000;
2982 break; 2982 break;
2983 case 0x258: 2983 case 0x258:
2984 case 0x260: 2984 case 0x260:
2985 fp->rate_max = fp->rate_min = 96000; 2985 fp->rate_max = fp->rate_min = 96000;
2986 break; 2986 break;
2987 default: 2987 default:
2988 snd_printk(KERN_ERR "unknown sample rate\n"); 2988 snd_printk(KERN_ERR "unknown sample rate\n");
2989 kfree(fp); 2989 kfree(fp);
2990 return -ENXIO; 2990 return -ENXIO;
2991 } 2991 }
2992 2992
2993 stream = (fp->endpoint & USB_DIR_IN) 2993 stream = (fp->endpoint & USB_DIR_IN)
2994 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 2994 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2995 err = add_audio_endpoint(chip, stream, fp); 2995 err = add_audio_endpoint(chip, stream, fp);
2996 if (err < 0) { 2996 if (err < 0) {
2997 kfree(fp); 2997 kfree(fp);
2998 return err; 2998 return err;
2999 } 2999 }
3000 usb_set_interface(chip->dev, fp->iface, 0); 3000 usb_set_interface(chip->dev, fp->iface, 0);
3001 return 0; 3001 return 0;
3002 } 3002 }
3003 3003
3004 /* 3004 /*
3005 * Create a stream for an Edirol UA-1000 interface. 3005 * Create a stream for an Edirol UA-1000 interface.
3006 */ 3006 */
3007 static int create_ua1000_quirk(struct snd_usb_audio *chip, 3007 static int create_ua1000_quirk(struct snd_usb_audio *chip,
3008 struct usb_interface *iface, 3008 struct usb_interface *iface,
3009 const struct snd_usb_audio_quirk *quirk) 3009 const struct snd_usb_audio_quirk *quirk)
3010 { 3010 {
3011 static const struct audioformat ua1000_format = { 3011 static const struct audioformat ua1000_format = {
3012 .format = SNDRV_PCM_FORMAT_S32_LE, 3012 .format = SNDRV_PCM_FORMAT_S32_LE,
3013 .fmt_type = USB_FORMAT_TYPE_I, 3013 .fmt_type = USB_FORMAT_TYPE_I,
3014 .altsetting = 1, 3014 .altsetting = 1,
3015 .altset_idx = 1, 3015 .altset_idx = 1,
3016 .attributes = 0, 3016 .attributes = 0,
3017 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3017 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3018 }; 3018 };
3019 struct usb_host_interface *alts; 3019 struct usb_host_interface *alts;
3020 struct usb_interface_descriptor *altsd; 3020 struct usb_interface_descriptor *altsd;
3021 struct audioformat *fp; 3021 struct audioformat *fp;
3022 int stream, err; 3022 int stream, err;
3023 3023
3024 if (iface->num_altsetting != 2) 3024 if (iface->num_altsetting != 2)
3025 return -ENXIO; 3025 return -ENXIO;
3026 alts = &iface->altsetting[1]; 3026 alts = &iface->altsetting[1];
3027 altsd = get_iface_desc(alts); 3027 altsd = get_iface_desc(alts);
3028 if (alts->extralen != 11 || alts->extra[1] != USB_DT_CS_INTERFACE || 3028 if (alts->extralen != 11 || alts->extra[1] != USB_DT_CS_INTERFACE ||
3029 altsd->bNumEndpoints != 1) 3029 altsd->bNumEndpoints != 1)
3030 return -ENXIO; 3030 return -ENXIO;
3031 3031
3032 fp = kmalloc(sizeof(*fp), GFP_KERNEL); 3032 fp = kmalloc(sizeof(*fp), GFP_KERNEL);
3033 if (!fp) 3033 if (!fp)
3034 return -ENOMEM; 3034 return -ENOMEM;
3035 memcpy(fp, &ua1000_format, sizeof(*fp)); 3035 memcpy(fp, &ua1000_format, sizeof(*fp));
3036 3036
3037 fp->channels = alts->extra[4]; 3037 fp->channels = alts->extra[4];
3038 fp->iface = altsd->bInterfaceNumber; 3038 fp->iface = altsd->bInterfaceNumber;
3039 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 3039 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
3040 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 3040 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
3041 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 3041 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3042 fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]); 3042 fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
3043 3043
3044 stream = (fp->endpoint & USB_DIR_IN) 3044 stream = (fp->endpoint & USB_DIR_IN)
3045 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 3045 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
3046 err = add_audio_endpoint(chip, stream, fp); 3046 err = add_audio_endpoint(chip, stream, fp);
3047 if (err < 0) { 3047 if (err < 0) {
3048 kfree(fp); 3048 kfree(fp);
3049 return err; 3049 return err;
3050 } 3050 }
3051 /* FIXME: playback must be synchronized to capture */ 3051 /* FIXME: playback must be synchronized to capture */
3052 usb_set_interface(chip->dev, fp->iface, 0); 3052 usb_set_interface(chip->dev, fp->iface, 0);
3053 return 0; 3053 return 0;
3054 } 3054 }
3055 3055
3056 static int snd_usb_create_quirk(struct snd_usb_audio *chip, 3056 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3057 struct usb_interface *iface, 3057 struct usb_interface *iface,
3058 const struct snd_usb_audio_quirk *quirk); 3058 const struct snd_usb_audio_quirk *quirk);
3059 3059
3060 /* 3060 /*
3061 * handle the quirks for the contained interfaces 3061 * handle the quirks for the contained interfaces
3062 */ 3062 */
3063 static int create_composite_quirk(struct snd_usb_audio *chip, 3063 static int create_composite_quirk(struct snd_usb_audio *chip,
3064 struct usb_interface *iface, 3064 struct usb_interface *iface,
3065 const struct snd_usb_audio_quirk *quirk) 3065 const struct snd_usb_audio_quirk *quirk)
3066 { 3066 {
3067 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber; 3067 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
3068 int err; 3068 int err;
3069 3069
3070 for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) { 3070 for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) {
3071 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum); 3071 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
3072 if (!iface) 3072 if (!iface)
3073 continue; 3073 continue;
3074 if (quirk->ifnum != probed_ifnum && 3074 if (quirk->ifnum != probed_ifnum &&
3075 usb_interface_claimed(iface)) 3075 usb_interface_claimed(iface))
3076 continue; 3076 continue;
3077 err = snd_usb_create_quirk(chip, iface, quirk); 3077 err = snd_usb_create_quirk(chip, iface, quirk);
3078 if (err < 0) 3078 if (err < 0)
3079 return err; 3079 return err;
3080 if (quirk->ifnum != probed_ifnum) 3080 if (quirk->ifnum != probed_ifnum)
3081 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L); 3081 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
3082 } 3082 }
3083 return 0; 3083 return 0;
3084 } 3084 }
3085 3085
3086 static int ignore_interface_quirk(struct snd_usb_audio *chip, 3086 static int ignore_interface_quirk(struct snd_usb_audio *chip,
3087 struct usb_interface *iface, 3087 struct usb_interface *iface,
3088 const struct snd_usb_audio_quirk *quirk) 3088 const struct snd_usb_audio_quirk *quirk)
3089 { 3089 {
3090 return 0; 3090 return 0;
3091 } 3091 }
3092 3092
3093 3093
3094 /* 3094 /*
3095 * boot quirks 3095 * boot quirks
3096 */ 3096 */
3097 3097
3098 #define EXTIGY_FIRMWARE_SIZE_OLD 794 3098 #define EXTIGY_FIRMWARE_SIZE_OLD 794
3099 #define EXTIGY_FIRMWARE_SIZE_NEW 483 3099 #define EXTIGY_FIRMWARE_SIZE_NEW 483
3100 3100
3101 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf) 3101 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
3102 { 3102 {
3103 struct usb_host_config *config = dev->actconfig; 3103 struct usb_host_config *config = dev->actconfig;
3104 int err; 3104 int err;
3105 3105
3106 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD || 3106 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
3107 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) { 3107 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
3108 snd_printdd("sending Extigy boot sequence...\n"); 3108 snd_printdd("sending Extigy boot sequence...\n");
3109 /* Send message to force it to reconnect with full interface. */ 3109 /* Send message to force it to reconnect with full interface. */
3110 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0), 3110 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
3111 0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000); 3111 0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000);
3112 if (err < 0) snd_printdd("error sending boot message: %d\n", err); 3112 if (err < 0) snd_printdd("error sending boot message: %d\n", err);
3113 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, 3113 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
3114 &dev->descriptor, sizeof(dev->descriptor)); 3114 &dev->descriptor, sizeof(dev->descriptor));
3115 config = dev->actconfig; 3115 config = dev->actconfig;
3116 if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err); 3116 if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
3117 err = usb_reset_configuration(dev); 3117 err = usb_reset_configuration(dev);
3118 if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err); 3118 if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
3119 snd_printdd("extigy_boot: new boot length = %d\n", 3119 snd_printdd("extigy_boot: new boot length = %d\n",
3120 le16_to_cpu(get_cfg_desc(config)->wTotalLength)); 3120 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
3121 return -ENODEV; /* quit this anyway */ 3121 return -ENODEV; /* quit this anyway */
3122 } 3122 }
3123 return 0; 3123 return 0;
3124 } 3124 }
3125 3125
3126 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev) 3126 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
3127 { 3127 {
3128 u8 buf = 1; 3128 u8 buf = 1;
3129 3129
3130 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a, 3130 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
3131 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER, 3131 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3132 0, 0, &buf, 1, 1000); 3132 0, 0, &buf, 1, 1000);
3133 if (buf == 0) { 3133 if (buf == 0) {
3134 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29, 3134 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
3135 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 3135 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3136 1, 2000, NULL, 0, 1000); 3136 1, 2000, NULL, 0, 1000);
3137 return -ENODEV; 3137 return -ENODEV;
3138 } 3138 }
3139 return 0; 3139 return 0;
3140 } 3140 }
3141 3141
3142 /* 3142 /*
3143 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely 3143 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
3144 * documented in the device's data sheet. 3144 * documented in the device's data sheet.
3145 */ 3145 */
3146 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value) 3146 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
3147 { 3147 {
3148 u8 buf[4]; 3148 u8 buf[4];
3149 buf[0] = 0x20; 3149 buf[0] = 0x20;
3150 buf[1] = value & 0xff; 3150 buf[1] = value & 0xff;
3151 buf[2] = (value >> 8) & 0xff; 3151 buf[2] = (value >> 8) & 0xff;
3152 buf[3] = reg; 3152 buf[3] = reg;
3153 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION, 3153 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
3154 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 3154 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
3155 0, 0, &buf, 4, 1000); 3155 0, 0, &buf, 4, 1000);
3156 } 3156 }
3157 3157
3158 static int snd_usb_cm106_boot_quirk(struct usb_device *dev) 3158 static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
3159 { 3159 {
3160 /* 3160 /*
3161 * Enable line-out driver mode, set headphone source to front 3161 * Enable line-out driver mode, set headphone source to front
3162 * channels, enable stereo mic. 3162 * channels, enable stereo mic.
3163 */ 3163 */
3164 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004); 3164 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
3165 } 3165 }
3166 3166
3167 3167
3168 /* 3168 /*
3169 * Setup quirks 3169 * Setup quirks
3170 */ 3170 */
3171 #define AUDIOPHILE_SET 0x01 /* if set, parse device_setup */ 3171 #define AUDIOPHILE_SET 0x01 /* if set, parse device_setup */
3172 #define AUDIOPHILE_SET_DTS 0x02 /* if set, enable DTS Digital Output */ 3172 #define AUDIOPHILE_SET_DTS 0x02 /* if set, enable DTS Digital Output */
3173 #define AUDIOPHILE_SET_96K 0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */ 3173 #define AUDIOPHILE_SET_96K 0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */
3174 #define AUDIOPHILE_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */ 3174 #define AUDIOPHILE_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */
3175 #define AUDIOPHILE_SET_DI 0x10 /* if set, enable Digital Input */ 3175 #define AUDIOPHILE_SET_DI 0x10 /* if set, enable Digital Input */
3176 #define AUDIOPHILE_SET_MASK 0x1F /* bit mask for setup value */ 3176 #define AUDIOPHILE_SET_MASK 0x1F /* bit mask for setup value */
3177 #define AUDIOPHILE_SET_24B_48K_DI 0x19 /* value for 24bits+48KHz+Digital Input */ 3177 #define AUDIOPHILE_SET_24B_48K_DI 0x19 /* value for 24bits+48KHz+Digital Input */
3178 #define AUDIOPHILE_SET_24B_48K_NOTDI 0x09 /* value for 24bits+48KHz+No Digital Input */ 3178 #define AUDIOPHILE_SET_24B_48K_NOTDI 0x09 /* value for 24bits+48KHz+No Digital Input */
3179 #define AUDIOPHILE_SET_16B_48K_DI 0x11 /* value for 16bits+48KHz+Digital Input */ 3179 #define AUDIOPHILE_SET_16B_48K_DI 0x11 /* value for 16bits+48KHz+Digital Input */
3180 #define AUDIOPHILE_SET_16B_48K_NOTDI 0x01 /* value for 16bits+48KHz+No Digital Input */ 3180 #define AUDIOPHILE_SET_16B_48K_NOTDI 0x01 /* value for 16bits+48KHz+No Digital Input */
3181 3181
3182 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip, 3182 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
3183 int iface, int altno) 3183 int iface, int altno)
3184 { 3184 {
3185 if (device_setup[chip->index] & AUDIOPHILE_SET) { 3185 if (device_setup[chip->index] & AUDIOPHILE_SET) {
3186 if ((device_setup[chip->index] & AUDIOPHILE_SET_DTS) 3186 if ((device_setup[chip->index] & AUDIOPHILE_SET_DTS)
3187 && altno != 6) 3187 && altno != 6)
3188 return 1; /* skip this altsetting */ 3188 return 1; /* skip this altsetting */
3189 if ((device_setup[chip->index] & AUDIOPHILE_SET_96K) 3189 if ((device_setup[chip->index] & AUDIOPHILE_SET_96K)
3190 && altno != 1) 3190 && altno != 1)
3191 return 1; /* skip this altsetting */ 3191 return 1; /* skip this altsetting */
3192 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) == 3192 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3193 AUDIOPHILE_SET_24B_48K_DI && altno != 2) 3193 AUDIOPHILE_SET_24B_48K_DI && altno != 2)
3194 return 1; /* skip this altsetting */ 3194 return 1; /* skip this altsetting */
3195 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) == 3195 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3196 AUDIOPHILE_SET_24B_48K_NOTDI && altno != 3) 3196 AUDIOPHILE_SET_24B_48K_NOTDI && altno != 3)
3197 return 1; /* skip this altsetting */ 3197 return 1; /* skip this altsetting */
3198 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) == 3198 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3199 AUDIOPHILE_SET_16B_48K_DI && altno != 4) 3199 AUDIOPHILE_SET_16B_48K_DI && altno != 4)
3200 return 1; /* skip this altsetting */ 3200 return 1; /* skip this altsetting */
3201 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) == 3201 if ((device_setup[chip->index] & AUDIOPHILE_SET_MASK) ==
3202 AUDIOPHILE_SET_16B_48K_NOTDI && altno != 5) 3202 AUDIOPHILE_SET_16B_48K_NOTDI && altno != 5)
3203 return 1; /* skip this altsetting */ 3203 return 1; /* skip this altsetting */
3204 } 3204 }
3205 return 0; /* keep this altsetting */ 3205 return 0; /* keep this altsetting */
3206 } 3206 }
3207 3207
3208 /* 3208 /*
3209 * audio-interface quirks 3209 * audio-interface quirks
3210 * 3210 *
3211 * returns zero if no standard audio/MIDI parsing is needed. 3211 * returns zero if no standard audio/MIDI parsing is needed.
3212 * returns a postive value if standard audio/midi interfaces are parsed 3212 * returns a postive value if standard audio/midi interfaces are parsed
3213 * after this. 3213 * after this.
3214 * returns a negative value at error. 3214 * returns a negative value at error.
3215 */ 3215 */
3216 static int snd_usb_create_quirk(struct snd_usb_audio *chip, 3216 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
3217 struct usb_interface *iface, 3217 struct usb_interface *iface,
3218 const struct snd_usb_audio_quirk *quirk) 3218 const struct snd_usb_audio_quirk *quirk)
3219 { 3219 {
3220 typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *, 3220 typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *,
3221 const struct snd_usb_audio_quirk *); 3221 const struct snd_usb_audio_quirk *);
3222 static const quirk_func_t quirk_funcs[] = { 3222 static const quirk_func_t quirk_funcs[] = {
3223 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk, 3223 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
3224 [QUIRK_COMPOSITE] = create_composite_quirk, 3224 [QUIRK_COMPOSITE] = create_composite_quirk,
3225 [QUIRK_MIDI_STANDARD_INTERFACE] = snd_usb_create_midi_interface, 3225 [QUIRK_MIDI_STANDARD_INTERFACE] = snd_usb_create_midi_interface,
3226 [QUIRK_MIDI_FIXED_ENDPOINT] = snd_usb_create_midi_interface, 3226 [QUIRK_MIDI_FIXED_ENDPOINT] = snd_usb_create_midi_interface,
3227 [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface, 3227 [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface,
3228 [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface, 3228 [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface,
3229 [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface, 3229 [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface,
3230 [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface, 3230 [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface,
3231 [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface, 3231 [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
3232 [QUIRK_MIDI_CME] = snd_usb_create_midi_interface, 3232 [QUIRK_MIDI_CME] = snd_usb_create_midi_interface,
3233 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk, 3233 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
3234 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk, 3234 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
3235 [QUIRK_AUDIO_EDIROL_UA700_UA25] = create_ua700_ua25_quirk, 3235 [QUIRK_AUDIO_EDIROL_UA700_UA25] = create_ua700_ua25_quirk,
3236 [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk, 3236 [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk,
3237 }; 3237 };
3238 3238
3239 if (quirk->type < QUIRK_TYPE_COUNT) { 3239 if (quirk->type < QUIRK_TYPE_COUNT) {
3240 return quirk_funcs[quirk->type](chip, iface, quirk); 3240 return quirk_funcs[quirk->type](chip, iface, quirk);
3241 } else { 3241 } else {
3242 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type); 3242 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
3243 return -ENXIO; 3243 return -ENXIO;
3244 } 3244 }
3245 } 3245 }
3246 3246
3247 3247
3248 /* 3248 /*
3249 * common proc files to show the usb device info 3249 * common proc files to show the usb device info
3250 */ 3250 */
3251 static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) 3251 static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3252 { 3252 {
3253 struct snd_usb_audio *chip = entry->private_data; 3253 struct snd_usb_audio *chip = entry->private_data;
3254 if (! chip->shutdown) 3254 if (! chip->shutdown)
3255 snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum); 3255 snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
3256 } 3256 }
3257 3257
3258 static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) 3258 static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
3259 { 3259 {
3260 struct snd_usb_audio *chip = entry->private_data; 3260 struct snd_usb_audio *chip = entry->private_data;
3261 if (! chip->shutdown) 3261 if (! chip->shutdown)
3262 snd_iprintf(buffer, "%04x:%04x\n", 3262 snd_iprintf(buffer, "%04x:%04x\n",
3263 USB_ID_VENDOR(chip->usb_id), 3263 USB_ID_VENDOR(chip->usb_id),
3264 USB_ID_PRODUCT(chip->usb_id)); 3264 USB_ID_PRODUCT(chip->usb_id));
3265 } 3265 }
3266 3266
3267 static void snd_usb_audio_create_proc(struct snd_usb_audio *chip) 3267 static void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
3268 { 3268 {
3269 struct snd_info_entry *entry; 3269 struct snd_info_entry *entry;
3270 if (! snd_card_proc_new(chip->card, "usbbus", &entry)) 3270 if (! snd_card_proc_new(chip->card, "usbbus", &entry))
3271 snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read); 3271 snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
3272 if (! snd_card_proc_new(chip->card, "usbid", &entry)) 3272 if (! snd_card_proc_new(chip->card, "usbid", &entry))
3273 snd_info_set_text_ops(entry, chip, proc_audio_usbid_read); 3273 snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
3274 } 3274 }
3275 3275
3276 /* 3276 /*
3277 * free the chip instance 3277 * free the chip instance
3278 * 3278 *
3279 * here we have to do not much, since pcm and controls are already freed 3279 * here we have to do not much, since pcm and controls are already freed
3280 * 3280 *
3281 */ 3281 */
3282 3282
3283 static int snd_usb_audio_free(struct snd_usb_audio *chip) 3283 static int snd_usb_audio_free(struct snd_usb_audio *chip)
3284 { 3284 {
3285 kfree(chip); 3285 kfree(chip);
3286 return 0; 3286 return 0;
3287 } 3287 }
3288 3288
3289 static int snd_usb_audio_dev_free(struct snd_device *device) 3289 static int snd_usb_audio_dev_free(struct snd_device *device)
3290 { 3290 {
3291 struct snd_usb_audio *chip = device->device_data; 3291 struct snd_usb_audio *chip = device->device_data;
3292 return snd_usb_audio_free(chip); 3292 return snd_usb_audio_free(chip);
3293 } 3293 }
3294 3294
3295 3295
3296 /* 3296 /*
3297 * create a chip instance and set its names. 3297 * create a chip instance and set its names.
3298 */ 3298 */
3299 static int snd_usb_audio_create(struct usb_device *dev, int idx, 3299 static int snd_usb_audio_create(struct usb_device *dev, int idx,
3300 const struct snd_usb_audio_quirk *quirk, 3300 const struct snd_usb_audio_quirk *quirk,
3301 struct snd_usb_audio **rchip) 3301 struct snd_usb_audio **rchip)
3302 { 3302 {
3303 struct snd_card *card; 3303 struct snd_card *card;
3304 struct snd_usb_audio *chip; 3304 struct snd_usb_audio *chip;
3305 int err, len; 3305 int err, len;
3306 char component[14]; 3306 char component[14];
3307 static struct snd_device_ops ops = { 3307 static struct snd_device_ops ops = {
3308 .dev_free = snd_usb_audio_dev_free, 3308 .dev_free = snd_usb_audio_dev_free,
3309 }; 3309 };
3310 3310
3311 *rchip = NULL; 3311 *rchip = NULL;
3312 3312
3313 if (snd_usb_get_speed(dev) != USB_SPEED_FULL && 3313 if (snd_usb_get_speed(dev) != USB_SPEED_FULL &&
3314 snd_usb_get_speed(dev) != USB_SPEED_HIGH) { 3314 snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
3315 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev)); 3315 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
3316 return -ENXIO; 3316 return -ENXIO;
3317 } 3317 }
3318 3318
3319 card = snd_card_new(index[idx], id[idx], THIS_MODULE, 0); 3319 card = snd_card_new(index[idx], id[idx], THIS_MODULE, 0);
3320 if (card == NULL) { 3320 if (card == NULL) {
3321 snd_printk(KERN_ERR "cannot create card instance %d\n", idx); 3321 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
3322 return -ENOMEM; 3322 return -ENOMEM;
3323 } 3323 }
3324 3324
3325 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 3325 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
3326 if (! chip) { 3326 if (! chip) {
3327 snd_card_free(card); 3327 snd_card_free(card);
3328 return -ENOMEM; 3328 return -ENOMEM;
3329 } 3329 }
3330 3330
3331 chip->index = idx; 3331 chip->index = idx;
3332 chip->dev = dev; 3332 chip->dev = dev;
3333 chip->card = card; 3333 chip->card = card;
3334 chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor), 3334 chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3335 le16_to_cpu(dev->descriptor.idProduct)); 3335 le16_to_cpu(dev->descriptor.idProduct));
3336 INIT_LIST_HEAD(&chip->pcm_list); 3336 INIT_LIST_HEAD(&chip->pcm_list);
3337 INIT_LIST_HEAD(&chip->midi_list); 3337 INIT_LIST_HEAD(&chip->midi_list);
3338 INIT_LIST_HEAD(&chip->mixer_list); 3338 INIT_LIST_HEAD(&chip->mixer_list);
3339 3339
3340 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 3340 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
3341 snd_usb_audio_free(chip); 3341 snd_usb_audio_free(chip);
3342 snd_card_free(card); 3342 snd_card_free(card);
3343 return err; 3343 return err;
3344 } 3344 }
3345 3345
3346 strcpy(card->driver, "USB-Audio"); 3346 strcpy(card->driver, "USB-Audio");
3347 sprintf(component, "USB%04x:%04x", 3347 sprintf(component, "USB%04x:%04x",
3348 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); 3348 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
3349 snd_component_add(card, component); 3349 snd_component_add(card, component);
3350 3350
3351 /* retrieve the device string as shortname */ 3351 /* retrieve the device string as shortname */
3352 if (quirk && quirk->product_name) { 3352 if (quirk && quirk->product_name) {
3353 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname)); 3353 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
3354 } else { 3354 } else {
3355 if (!dev->descriptor.iProduct || 3355 if (!dev->descriptor.iProduct ||
3356 usb_string(dev, dev->descriptor.iProduct, 3356 usb_string(dev, dev->descriptor.iProduct,
3357 card->shortname, sizeof(card->shortname)) <= 0) { 3357 card->shortname, sizeof(card->shortname)) <= 0) {
3358 /* no name available from anywhere, so use ID */ 3358 /* no name available from anywhere, so use ID */
3359 sprintf(card->shortname, "USB Device %#04x:%#04x", 3359 sprintf(card->shortname, "USB Device %#04x:%#04x",
3360 USB_ID_VENDOR(chip->usb_id), 3360 USB_ID_VENDOR(chip->usb_id),
3361 USB_ID_PRODUCT(chip->usb_id)); 3361 USB_ID_PRODUCT(chip->usb_id));
3362 } 3362 }
3363 } 3363 }
3364 3364
3365 /* retrieve the vendor and device strings as longname */ 3365 /* retrieve the vendor and device strings as longname */
3366 if (quirk && quirk->vendor_name) { 3366 if (quirk && quirk->vendor_name) {
3367 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname)); 3367 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
3368 } else { 3368 } else {
3369 if (dev->descriptor.iManufacturer) 3369 if (dev->descriptor.iManufacturer)
3370 len = usb_string(dev, dev->descriptor.iManufacturer, 3370 len = usb_string(dev, dev->descriptor.iManufacturer,
3371 card->longname, sizeof(card->longname)); 3371 card->longname, sizeof(card->longname));
3372 else 3372 else
3373 len = 0; 3373 len = 0;
3374 /* we don't really care if there isn't any vendor string */ 3374 /* we don't really care if there isn't any vendor string */
3375 } 3375 }
3376 if (len > 0) 3376 if (len > 0)
3377 strlcat(card->longname, " ", sizeof(card->longname)); 3377 strlcat(card->longname, " ", sizeof(card->longname));
3378 3378
3379 strlcat(card->longname, card->shortname, sizeof(card->longname)); 3379 strlcat(card->longname, card->shortname, sizeof(card->longname));
3380 3380
3381 len = strlcat(card->longname, " at ", sizeof(card->longname)); 3381 len = strlcat(card->longname, " at ", sizeof(card->longname));
3382 3382
3383 if (len < sizeof(card->longname)) 3383 if (len < sizeof(card->longname))
3384 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len); 3384 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
3385 3385
3386 strlcat(card->longname, 3386 strlcat(card->longname,
3387 snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" : ", high speed", 3387 snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" : ", high speed",
3388 sizeof(card->longname)); 3388 sizeof(card->longname));
3389 3389
3390 snd_usb_audio_create_proc(chip); 3390 snd_usb_audio_create_proc(chip);
3391 3391
3392 *rchip = chip; 3392 *rchip = chip;
3393 return 0; 3393 return 0;
3394 } 3394 }
3395 3395
3396 3396
3397 /* 3397 /*
3398 * probe the active usb device 3398 * probe the active usb device
3399 * 3399 *
3400 * note that this can be called multiple times per a device, when it 3400 * note that this can be called multiple times per a device, when it
3401 * includes multiple audio control interfaces. 3401 * includes multiple audio control interfaces.
3402 * 3402 *
3403 * thus we check the usb device pointer and creates the card instance 3403 * thus we check the usb device pointer and creates the card instance
3404 * only at the first time. the successive calls of this function will 3404 * only at the first time. the successive calls of this function will
3405 * append the pcm interface to the corresponding card. 3405 * append the pcm interface to the corresponding card.
3406 */ 3406 */
3407 static void *snd_usb_audio_probe(struct usb_device *dev, 3407 static void *snd_usb_audio_probe(struct usb_device *dev,
3408 struct usb_interface *intf, 3408 struct usb_interface *intf,
3409 const struct usb_device_id *usb_id) 3409 const struct usb_device_id *usb_id)
3410 { 3410 {
3411 const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info; 3411 const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info;
3412 int i, err; 3412 int i, err;
3413 struct snd_usb_audio *chip; 3413 struct snd_usb_audio *chip;
3414 struct usb_host_interface *alts; 3414 struct usb_host_interface *alts;
3415 int ifnum; 3415 int ifnum;
3416 u32 id; 3416 u32 id;
3417 3417
3418 alts = &intf->altsetting[0]; 3418 alts = &intf->altsetting[0];
3419 ifnum = get_iface_desc(alts)->bInterfaceNumber; 3419 ifnum = get_iface_desc(alts)->bInterfaceNumber;
3420 id = USB_ID(le16_to_cpu(dev->descriptor.idVendor), 3420 id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3421 le16_to_cpu(dev->descriptor.idProduct)); 3421 le16_to_cpu(dev->descriptor.idProduct));
3422 3422
3423 if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum) 3423 if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
3424 goto __err_val; 3424 goto __err_val;
3425 3425
3426 /* SB Extigy needs special boot-up sequence */ 3426 /* SB Extigy needs special boot-up sequence */
3427 /* if more models come, this will go to the quirk list. */ 3427 /* if more models come, this will go to the quirk list. */
3428 if (id == USB_ID(0x041e, 0x3000)) { 3428 if (id == USB_ID(0x041e, 0x3000)) {
3429 if (snd_usb_extigy_boot_quirk(dev, intf) < 0) 3429 if (snd_usb_extigy_boot_quirk(dev, intf) < 0)
3430 goto __err_val; 3430 goto __err_val;
3431 } 3431 }
3432 /* SB Audigy 2 NX needs its own boot-up magic, too */ 3432 /* SB Audigy 2 NX needs its own boot-up magic, too */
3433 if (id == USB_ID(0x041e, 0x3020)) { 3433 if (id == USB_ID(0x041e, 0x3020)) {
3434 if (snd_usb_audigy2nx_boot_quirk(dev) < 0) 3434 if (snd_usb_audigy2nx_boot_quirk(dev) < 0)
3435 goto __err_val; 3435 goto __err_val;
3436 } 3436 }
3437 3437
3438 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */ 3438 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
3439 if (id == USB_ID(0x10f5, 0x0200)) { 3439 if (id == USB_ID(0x10f5, 0x0200)) {
3440 if (snd_usb_cm106_boot_quirk(dev) < 0) 3440 if (snd_usb_cm106_boot_quirk(dev) < 0)
3441 goto __err_val; 3441 goto __err_val;
3442 } 3442 }
3443 3443
3444 /* 3444 /*
3445 * found a config. now register to ALSA 3445 * found a config. now register to ALSA
3446 */ 3446 */
3447 3447
3448 /* check whether it's already registered */ 3448 /* check whether it's already registered */
3449 chip = NULL; 3449 chip = NULL;
3450 mutex_lock(&register_mutex); 3450 mutex_lock(&register_mutex);
3451 for (i = 0; i < SNDRV_CARDS; i++) { 3451 for (i = 0; i < SNDRV_CARDS; i++) {
3452 if (usb_chip[i] && usb_chip[i]->dev == dev) { 3452 if (usb_chip[i] && usb_chip[i]->dev == dev) {
3453 if (usb_chip[i]->shutdown) { 3453 if (usb_chip[i]->shutdown) {
3454 snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n"); 3454 snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
3455 goto __error; 3455 goto __error;
3456 } 3456 }
3457 chip = usb_chip[i]; 3457 chip = usb_chip[i];
3458 break; 3458 break;
3459 } 3459 }
3460 } 3460 }
3461 if (! chip) { 3461 if (! chip) {
3462 /* it's a fresh one. 3462 /* it's a fresh one.
3463 * now look for an empty slot and create a new card instance 3463 * now look for an empty slot and create a new card instance
3464 */ 3464 */
3465 for (i = 0; i < SNDRV_CARDS; i++) 3465 for (i = 0; i < SNDRV_CARDS; i++)
3466 if (enable[i] && ! usb_chip[i] && 3466 if (enable[i] && ! usb_chip[i] &&
3467 (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) && 3467 (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
3468 (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) { 3468 (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
3469 if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) { 3469 if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
3470 goto __error; 3470 goto __error;
3471 } 3471 }
3472 snd_card_set_dev(chip->card, &intf->dev); 3472 snd_card_set_dev(chip->card, &intf->dev);
3473 break; 3473 break;
3474 } 3474 }
3475 if (! chip) { 3475 if (! chip) {
3476 snd_printk(KERN_ERR "no available usb audio device\n"); 3476 snd_printk(KERN_ERR "no available usb audio device\n");
3477 goto __error; 3477 goto __error;
3478 } 3478 }
3479 } 3479 }
3480 3480
3481 err = 1; /* continue */ 3481 err = 1; /* continue */
3482 if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) { 3482 if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
3483 /* need some special handlings */ 3483 /* need some special handlings */
3484 if ((err = snd_usb_create_quirk(chip, intf, quirk)) < 0) 3484 if ((err = snd_usb_create_quirk(chip, intf, quirk)) < 0)
3485 goto __error; 3485 goto __error;
3486 } 3486 }
3487 3487
3488 if (err > 0) { 3488 if (err > 0) {
3489 /* create normal USB audio interfaces */ 3489 /* create normal USB audio interfaces */
3490 if (snd_usb_create_streams(chip, ifnum) < 0 || 3490 if (snd_usb_create_streams(chip, ifnum) < 0 ||
3491 snd_usb_create_mixer(chip, ifnum) < 0) { 3491 snd_usb_create_mixer(chip, ifnum) < 0) {
3492 goto __error; 3492 goto __error;
3493 } 3493 }
3494 } 3494 }
3495 3495
3496 /* we are allowed to call snd_card_register() many times */ 3496 /* we are allowed to call snd_card_register() many times */
3497 if (snd_card_register(chip->card) < 0) { 3497 if (snd_card_register(chip->card) < 0) {
3498 goto __error; 3498 goto __error;
3499 } 3499 }
3500 3500
3501 usb_chip[chip->index] = chip; 3501 usb_chip[chip->index] = chip;
3502 chip->num_interfaces++; 3502 chip->num_interfaces++;
3503 mutex_unlock(&register_mutex); 3503 mutex_unlock(&register_mutex);
3504 return chip; 3504 return chip;
3505 3505
3506 __error: 3506 __error:
3507 if (chip && !chip->num_interfaces) 3507 if (chip && !chip->num_interfaces)
3508 snd_card_free(chip->card); 3508 snd_card_free(chip->card);
3509 mutex_unlock(&register_mutex); 3509 mutex_unlock(&register_mutex);
3510 __err_val: 3510 __err_val:
3511 return NULL; 3511 return NULL;
3512 } 3512 }
3513 3513
3514 /* 3514 /*
3515 * we need to take care of counter, since disconnection can be called also 3515 * we need to take care of counter, since disconnection can be called also
3516 * many times as well as usb_audio_probe(). 3516 * many times as well as usb_audio_probe().
3517 */ 3517 */
3518 static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr) 3518 static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
3519 { 3519 {
3520 struct snd_usb_audio *chip; 3520 struct snd_usb_audio *chip;
3521 struct snd_card *card; 3521 struct snd_card *card;
3522 struct list_head *p; 3522 struct list_head *p;
3523 3523
3524 if (ptr == (void *)-1L) 3524 if (ptr == (void *)-1L)
3525 return; 3525 return;
3526 3526
3527 chip = ptr; 3527 chip = ptr;
3528 card = chip->card; 3528 card = chip->card;
3529 mutex_lock(&register_mutex); 3529 mutex_lock(&register_mutex);
3530 chip->shutdown = 1; 3530 chip->shutdown = 1;
3531 chip->num_interfaces--; 3531 chip->num_interfaces--;
3532 if (chip->num_interfaces <= 0) { 3532 if (chip->num_interfaces <= 0) {
3533 snd_card_disconnect(card); 3533 snd_card_disconnect(card);
3534 /* release the pcm resources */ 3534 /* release the pcm resources */
3535 list_for_each(p, &chip->pcm_list) { 3535 list_for_each(p, &chip->pcm_list) {
3536 snd_usb_stream_disconnect(p); 3536 snd_usb_stream_disconnect(p);
3537 } 3537 }
3538 /* release the midi resources */ 3538 /* release the midi resources */
3539 list_for_each(p, &chip->midi_list) { 3539 list_for_each(p, &chip->midi_list) {
3540 snd_usbmidi_disconnect(p); 3540 snd_usbmidi_disconnect(p);
3541 } 3541 }
3542 /* release mixer resources */ 3542 /* release mixer resources */
3543 list_for_each(p, &chip->mixer_list) { 3543 list_for_each(p, &chip->mixer_list) {
3544 snd_usb_mixer_disconnect(p); 3544 snd_usb_mixer_disconnect(p);
3545 } 3545 }
3546 usb_chip[chip->index] = NULL; 3546 usb_chip[chip->index] = NULL;
3547 mutex_unlock(&register_mutex); 3547 mutex_unlock(&register_mutex);
3548 snd_card_free_when_closed(card); 3548 snd_card_free_when_closed(card);
3549 } else { 3549 } else {
3550 mutex_unlock(&register_mutex); 3550 mutex_unlock(&register_mutex);
3551 } 3551 }
3552 } 3552 }
3553 3553
3554 /* 3554 /*
3555 * new 2.5 USB kernel API 3555 * new 2.5 USB kernel API
3556 */ 3556 */
3557 static int usb_audio_probe(struct usb_interface *intf, 3557 static int usb_audio_probe(struct usb_interface *intf,
3558 const struct usb_device_id *id) 3558 const struct usb_device_id *id)
3559 { 3559 {
3560 void *chip; 3560 void *chip;
3561 chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id); 3561 chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
3562 if (chip) { 3562 if (chip) {
3563 dev_set_drvdata(&intf->dev, chip); 3563 dev_set_drvdata(&intf->dev, chip);
3564 return 0; 3564 return 0;
3565 } else 3565 } else
3566 return -EIO; 3566 return -EIO;
3567 } 3567 }
3568 3568
3569 static void usb_audio_disconnect(struct usb_interface *intf) 3569 static void usb_audio_disconnect(struct usb_interface *intf)
3570 { 3570 {
3571 snd_usb_audio_disconnect(interface_to_usbdev(intf), 3571 snd_usb_audio_disconnect(interface_to_usbdev(intf),
3572 dev_get_drvdata(&intf->dev)); 3572 dev_get_drvdata(&intf->dev));
3573 } 3573 }
3574 3574
3575 3575
3576 static int __init snd_usb_audio_init(void) 3576 static int __init snd_usb_audio_init(void)
3577 { 3577 {
3578 if (nrpacks < MIN_PACKS_URB || nrpacks > MAX_PACKS) { 3578 if (nrpacks < MIN_PACKS_URB || nrpacks > MAX_PACKS) {
3579 printk(KERN_WARNING "invalid nrpacks value.\n"); 3579 printk(KERN_WARNING "invalid nrpacks value.\n");
3580 return -EINVAL; 3580 return -EINVAL;
3581 } 3581 }
3582 usb_register(&usb_audio_driver); 3582 usb_register(&usb_audio_driver);
3583 return 0; 3583 return 0;
3584 } 3584 }
3585 3585
3586 3586
3587 static void __exit snd_usb_audio_cleanup(void) 3587 static void __exit snd_usb_audio_cleanup(void)
3588 { 3588 {
3589 usb_deregister(&usb_audio_driver); 3589 usb_deregister(&usb_audio_driver);
3590 } 3590 }
3591 3591
3592 module_init(snd_usb_audio_init); 3592 module_init(snd_usb_audio_init);
3593 module_exit(snd_usb_audio_cleanup); 3593 module_exit(snd_usb_audio_cleanup);
3594 3594