Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 68853fa30cdb6a9a92f7ab46c34aedb24b2f9d56

Authored by Andrew Morton
Committed by Takashi Iwai
1 parent baba2e0d2b
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches 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

ALSA: usb-audio: sound/usb/endpoint.c: suppress warning 

sound/usb/endpoint.c: In function 'queue_pending_output_urbs':
sound/usb/endpoint.c:298: warning: 'packet' may be used uninitialized in this function

Cc: Daniel Mack <zonque@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

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

sound/usb/endpoint.c
Diff comments   View file @ 68853fa
1 /* 1 /*
2 * This program is free software; you can redistribute it and/or modify 2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by 3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or 4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version. 5 * (at your option) any later version.
6 * 6 *
7 * This program is distributed in the hope that it will be useful, 7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details. 10 * GNU General Public License for more details.
11 * 11 *
12 * You should have received a copy of the GNU General Public License 12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software 13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 * 15 *
16 */ 16 */
17 17
18 #include <linux/gfp.h> 18 #include <linux/gfp.h>
19 #include <linux/init.h> 19 #include <linux/init.h>
20 #include <linux/ratelimit.h> 20 #include <linux/ratelimit.h>
21 #include <linux/usb.h> 21 #include <linux/usb.h>
22 #include <linux/usb/audio.h> 22 #include <linux/usb/audio.h>
23 #include <linux/slab.h> 23 #include <linux/slab.h>
24 24
25 #include <sound/core.h> 25 #include <sound/core.h>
26 #include <sound/pcm.h> 26 #include <sound/pcm.h>
27 #include <sound/pcm_params.h> 27 #include <sound/pcm_params.h>
28 28
29 #include "usbaudio.h" 29 #include "usbaudio.h"
30 #include "helper.h" 30 #include "helper.h"
31 #include "card.h" 31 #include "card.h"
32 #include "endpoint.h" 32 #include "endpoint.h"
33 #include "pcm.h" 33 #include "pcm.h"
34 34
35 #define EP_FLAG_ACTIVATED 0 35 #define EP_FLAG_ACTIVATED 0
36 #define EP_FLAG_RUNNING 1 36 #define EP_FLAG_RUNNING 1
37 37
38 /* 38 /*
39 * snd_usb_endpoint is a model that abstracts everything related to an 39 * snd_usb_endpoint is a model that abstracts everything related to an
40 * USB endpoint and its streaming. 40 * USB endpoint and its streaming.
41 * 41 *
42 * There are functions to activate and deactivate the streaming URBs and 42 * There are functions to activate and deactivate the streaming URBs and
43 * optinal callbacks to let the pcm logic handle the actual content of the 43 * optinal callbacks to let the pcm logic handle the actual content of the
44 * packets for playback and record. Thus, the bus streaming and the audio 44 * packets for playback and record. Thus, the bus streaming and the audio
45 * handlers are fully decoupled. 45 * handlers are fully decoupled.
46 * 46 *
47 * There are two different types of endpoints in for audio applications. 47 * There are two different types of endpoints in for audio applications.
48 * 48 *
49 * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both 49 * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
50 * inbound and outbound traffic. 50 * inbound and outbound traffic.
51 * 51 *
52 * SND_USB_ENDPOINT_TYPE_SYNC are for inbound traffic only and expect the 52 * SND_USB_ENDPOINT_TYPE_SYNC are for inbound traffic only and expect the
53 * payload to carry Q16.16 formatted sync information (3 or 4 bytes). 53 * payload to carry Q16.16 formatted sync information (3 or 4 bytes).
54 * 54 *
55 * Each endpoint has to be configured (by calling 55 * Each endpoint has to be configured (by calling
56 * snd_usb_endpoint_set_params()) before it can be used. 56 * snd_usb_endpoint_set_params()) before it can be used.
57 * 57 *
58 * The model incorporates a reference counting, so that multiple users 58 * The model incorporates a reference counting, so that multiple users
59 * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and 59 * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
60 * only the first user will effectively start the URBs, and only the last 60 * only the first user will effectively start the URBs, and only the last
61 * one will tear them down again. 61 * one will tear them down again.
62 */ 62 */
63 63
64 /* 64 /*
65 * convert a sampling rate into our full speed format (fs/1000 in Q16.16) 65 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
66 * this will overflow at approx 524 kHz 66 * this will overflow at approx 524 kHz
67 */ 67 */
68 static inline unsigned get_usb_full_speed_rate(unsigned int rate) 68 static inline unsigned get_usb_full_speed_rate(unsigned int rate)
69 { 69 {
70 return ((rate << 13) + 62) / 125; 70 return ((rate << 13) + 62) / 125;
71 } 71 }
72 72
73 /* 73 /*
74 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16) 74 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
75 * this will overflow at approx 4 MHz 75 * this will overflow at approx 4 MHz
76 */ 76 */
77 static inline unsigned get_usb_high_speed_rate(unsigned int rate) 77 static inline unsigned get_usb_high_speed_rate(unsigned int rate)
78 { 78 {
79 return ((rate << 10) + 62) / 125; 79 return ((rate << 10) + 62) / 125;
80 } 80 }
81 81
82 /* 82 /*
83 * release a urb data 83 * release a urb data
84 */ 84 */
85 static void release_urb_ctx(struct snd_urb_ctx *u) 85 static void release_urb_ctx(struct snd_urb_ctx *u)
86 { 86 {
87 if (u->buffer_size) 87 if (u->buffer_size)
88 usb_free_coherent(u->ep->chip->dev, u->buffer_size, 88 usb_free_coherent(u->ep->chip->dev, u->buffer_size,
89 u->urb->transfer_buffer, 89 u->urb->transfer_buffer,
90 u->urb->transfer_dma); 90 u->urb->transfer_dma);
91 usb_free_urb(u->urb); 91 usb_free_urb(u->urb);
92 u->urb = NULL; 92 u->urb = NULL;
93 } 93 }
94 94
95 static const char *usb_error_string(int err) 95 static const char *usb_error_string(int err)
96 { 96 {
97 switch (err) { 97 switch (err) {
98 case -ENODEV: 98 case -ENODEV:
99 return "no device"; 99 return "no device";
100 case -ENOENT: 100 case -ENOENT:
101 return "endpoint not enabled"; 101 return "endpoint not enabled";
102 case -EPIPE: 102 case -EPIPE:
103 return "endpoint stalled"; 103 return "endpoint stalled";
104 case -ENOSPC: 104 case -ENOSPC:
105 return "not enough bandwidth"; 105 return "not enough bandwidth";
106 case -ESHUTDOWN: 106 case -ESHUTDOWN:
107 return "device disabled"; 107 return "device disabled";
108 case -EHOSTUNREACH: 108 case -EHOSTUNREACH:
109 return "device suspended"; 109 return "device suspended";
110 case -EINVAL: 110 case -EINVAL:
111 case -EAGAIN: 111 case -EAGAIN:
112 case -EFBIG: 112 case -EFBIG:
113 case -EMSGSIZE: 113 case -EMSGSIZE:
114 return "internal error"; 114 return "internal error";
115 default: 115 default:
116 return "unknown error"; 116 return "unknown error";
117 } 117 }
118 } 118 }
119 119
120 /** 120 /**
121 * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type 121 * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
122 * 122 *
123 * @ep: The endpoint 123 * @ep: The endpoint
124 * 124 *
125 * Determine whether an endpoint is driven by an implicit feedback 125 * Determine whether an endpoint is driven by an implicit feedback
126 * data endpoint source. 126 * data endpoint source.
127 */ 127 */
128 int snd_usb_endpoint_implict_feedback_sink(struct snd_usb_endpoint *ep) 128 int snd_usb_endpoint_implict_feedback_sink(struct snd_usb_endpoint *ep)
129 { 129 {
130 return ep->sync_master && 130 return ep->sync_master &&
131 ep->sync_master->type == SND_USB_ENDPOINT_TYPE_DATA && 131 ep->sync_master->type == SND_USB_ENDPOINT_TYPE_DATA &&
132 ep->type == SND_USB_ENDPOINT_TYPE_DATA && 132 ep->type == SND_USB_ENDPOINT_TYPE_DATA &&
133 usb_pipeout(ep->pipe); 133 usb_pipeout(ep->pipe);
134 } 134 }
135 135
136 /* 136 /*
137 * For streaming based on information derived from sync endpoints, 137 * For streaming based on information derived from sync endpoints,
138 * prepare_outbound_urb_sizes() will call next_packet_size() to 138 * prepare_outbound_urb_sizes() will call next_packet_size() to
139 * determine the number of samples to be sent in the next packet. 139 * determine the number of samples to be sent in the next packet.
140 * 140 *
141 * For implicit feedback, next_packet_size() is unused. 141 * For implicit feedback, next_packet_size() is unused.
142 */ 142 */
143 static int next_packet_size(struct snd_usb_endpoint *ep) 143 static int next_packet_size(struct snd_usb_endpoint *ep)
144 { 144 {
145 unsigned long flags; 145 unsigned long flags;
146 int ret; 146 int ret;
147 147
148 if (ep->fill_max) 148 if (ep->fill_max)
149 return ep->maxframesize; 149 return ep->maxframesize;
150 150
151 spin_lock_irqsave(&ep->lock, flags); 151 spin_lock_irqsave(&ep->lock, flags);
152 ep->phase = (ep->phase & 0xffff) 152 ep->phase = (ep->phase & 0xffff)
153 + (ep->freqm << ep->datainterval); 153 + (ep->freqm << ep->datainterval);
154 ret = min(ep->phase >> 16, ep->maxframesize); 154 ret = min(ep->phase >> 16, ep->maxframesize);
155 spin_unlock_irqrestore(&ep->lock, flags); 155 spin_unlock_irqrestore(&ep->lock, flags);
156 156
157 return ret; 157 return ret;
158 } 158 }
159 159
160 static void retire_outbound_urb(struct snd_usb_endpoint *ep, 160 static void retire_outbound_urb(struct snd_usb_endpoint *ep,
161 struct snd_urb_ctx *urb_ctx) 161 struct snd_urb_ctx *urb_ctx)
162 { 162 {
163 if (ep->retire_data_urb) 163 if (ep->retire_data_urb)
164 ep->retire_data_urb(ep->data_subs, urb_ctx->urb); 164 ep->retire_data_urb(ep->data_subs, urb_ctx->urb);
165 } 165 }
166 166
167 static void retire_inbound_urb(struct snd_usb_endpoint *ep, 167 static void retire_inbound_urb(struct snd_usb_endpoint *ep,
168 struct snd_urb_ctx *urb_ctx) 168 struct snd_urb_ctx *urb_ctx)
169 { 169 {
170 struct urb *urb = urb_ctx->urb; 170 struct urb *urb = urb_ctx->urb;
171 171
172 if (ep->sync_slave) 172 if (ep->sync_slave)
173 snd_usb_handle_sync_urb(ep->sync_slave, ep, urb); 173 snd_usb_handle_sync_urb(ep->sync_slave, ep, urb);
174 174
175 if (ep->retire_data_urb) 175 if (ep->retire_data_urb)
176 ep->retire_data_urb(ep->data_subs, urb); 176 ep->retire_data_urb(ep->data_subs, urb);
177 } 177 }
178 178
179 static void prepare_outbound_urb_sizes(struct snd_usb_endpoint *ep, 179 static void prepare_outbound_urb_sizes(struct snd_usb_endpoint *ep,
180 struct snd_urb_ctx *ctx) 180 struct snd_urb_ctx *ctx)
181 { 181 {
182 int i; 182 int i;
183 183
184 for (i = 0; i < ctx->packets; ++i) 184 for (i = 0; i < ctx->packets; ++i)
185 ctx->packet_size[i] = next_packet_size(ep); 185 ctx->packet_size[i] = next_packet_size(ep);
186 } 186 }
187 187
188 /* 188 /*
189 * Prepare a PLAYBACK urb for submission to the bus. 189 * Prepare a PLAYBACK urb for submission to the bus.
190 */ 190 */
191 static void prepare_outbound_urb(struct snd_usb_endpoint *ep, 191 static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
192 struct snd_urb_ctx *ctx) 192 struct snd_urb_ctx *ctx)
193 { 193 {
194 int i; 194 int i;
195 struct urb *urb = ctx->urb; 195 struct urb *urb = ctx->urb;
196 unsigned char *cp = urb->transfer_buffer; 196 unsigned char *cp = urb->transfer_buffer;
197 197
198 urb->dev = ep->chip->dev; /* we need to set this at each time */ 198 urb->dev = ep->chip->dev; /* we need to set this at each time */
199 199
200 switch (ep->type) { 200 switch (ep->type) {
201 case SND_USB_ENDPOINT_TYPE_DATA: 201 case SND_USB_ENDPOINT_TYPE_DATA:
202 if (ep->prepare_data_urb) { 202 if (ep->prepare_data_urb) {
203 ep->prepare_data_urb(ep->data_subs, urb); 203 ep->prepare_data_urb(ep->data_subs, urb);
204 } else { 204 } else {
205 /* no data provider, so send silence */ 205 /* no data provider, so send silence */
206 unsigned int offs = 0; 206 unsigned int offs = 0;
207 for (i = 0; i < ctx->packets; ++i) { 207 for (i = 0; i < ctx->packets; ++i) {
208 int counts = ctx->packet_size[i]; 208 int counts = ctx->packet_size[i];
209 urb->iso_frame_desc[i].offset = offs * ep->stride; 209 urb->iso_frame_desc[i].offset = offs * ep->stride;
210 urb->iso_frame_desc[i].length = counts * ep->stride; 210 urb->iso_frame_desc[i].length = counts * ep->stride;
211 offs += counts; 211 offs += counts;
212 } 212 }
213 213
214 urb->number_of_packets = ctx->packets; 214 urb->number_of_packets = ctx->packets;
215 urb->transfer_buffer_length = offs * ep->stride; 215 urb->transfer_buffer_length = offs * ep->stride;
216 memset(urb->transfer_buffer, ep->silence_value, 216 memset(urb->transfer_buffer, ep->silence_value,
217 offs * ep->stride); 217 offs * ep->stride);
218 } 218 }
219 break; 219 break;
220 220
221 case SND_USB_ENDPOINT_TYPE_SYNC: 221 case SND_USB_ENDPOINT_TYPE_SYNC:
222 if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) { 222 if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
223 /* 223 /*
224 * fill the length and offset of each urb descriptor. 224 * fill the length and offset of each urb descriptor.
225 * the fixed 12.13 frequency is passed as 16.16 through the pipe. 225 * the fixed 12.13 frequency is passed as 16.16 through the pipe.
226 */ 226 */
227 urb->iso_frame_desc[0].length = 4; 227 urb->iso_frame_desc[0].length = 4;
228 urb->iso_frame_desc[0].offset = 0; 228 urb->iso_frame_desc[0].offset = 0;
229 cp[0] = ep->freqn; 229 cp[0] = ep->freqn;
230 cp[1] = ep->freqn >> 8; 230 cp[1] = ep->freqn >> 8;
231 cp[2] = ep->freqn >> 16; 231 cp[2] = ep->freqn >> 16;
232 cp[3] = ep->freqn >> 24; 232 cp[3] = ep->freqn >> 24;
233 } else { 233 } else {
234 /* 234 /*
235 * fill the length and offset of each urb descriptor. 235 * fill the length and offset of each urb descriptor.
236 * the fixed 10.14 frequency is passed through the pipe. 236 * the fixed 10.14 frequency is passed through the pipe.
237 */ 237 */
238 urb->iso_frame_desc[0].length = 3; 238 urb->iso_frame_desc[0].length = 3;
239 urb->iso_frame_desc[0].offset = 0; 239 urb->iso_frame_desc[0].offset = 0;
240 cp[0] = ep->freqn >> 2; 240 cp[0] = ep->freqn >> 2;
241 cp[1] = ep->freqn >> 10; 241 cp[1] = ep->freqn >> 10;
242 cp[2] = ep->freqn >> 18; 242 cp[2] = ep->freqn >> 18;
243 } 243 }
244 244
245 break; 245 break;
246 } 246 }
247 } 247 }
248 248
249 /* 249 /*
250 * Prepare a CAPTURE or SYNC urb for submission to the bus. 250 * Prepare a CAPTURE or SYNC urb for submission to the bus.
251 */ 251 */
252 static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep, 252 static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep,
253 struct snd_urb_ctx *urb_ctx) 253 struct snd_urb_ctx *urb_ctx)
254 { 254 {
255 int i, offs; 255 int i, offs;
256 struct urb *urb = urb_ctx->urb; 256 struct urb *urb = urb_ctx->urb;
257 257
258 urb->dev = ep->chip->dev; /* we need to set this at each time */ 258 urb->dev = ep->chip->dev; /* we need to set this at each time */
259 259
260 switch (ep->type) { 260 switch (ep->type) {
261 case SND_USB_ENDPOINT_TYPE_DATA: 261 case SND_USB_ENDPOINT_TYPE_DATA:
262 offs = 0; 262 offs = 0;
263 for (i = 0; i < urb_ctx->packets; i++) { 263 for (i = 0; i < urb_ctx->packets; i++) {
264 urb->iso_frame_desc[i].offset = offs; 264 urb->iso_frame_desc[i].offset = offs;
265 urb->iso_frame_desc[i].length = ep->curpacksize; 265 urb->iso_frame_desc[i].length = ep->curpacksize;
266 offs += ep->curpacksize; 266 offs += ep->curpacksize;
267 } 267 }
268 268
269 urb->transfer_buffer_length = offs; 269 urb->transfer_buffer_length = offs;
270 urb->number_of_packets = urb_ctx->packets; 270 urb->number_of_packets = urb_ctx->packets;
271 break; 271 break;
272 272
273 case SND_USB_ENDPOINT_TYPE_SYNC: 273 case SND_USB_ENDPOINT_TYPE_SYNC:
274 urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize); 274 urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
275 urb->iso_frame_desc[0].offset = 0; 275 urb->iso_frame_desc[0].offset = 0;
276 break; 276 break;
277 } 277 }
278 } 278 }
279 279
280 /* 280 /*
281 * Send output urbs that have been prepared previously. Urbs are dequeued 281 * Send output urbs that have been prepared previously. Urbs are dequeued
282 * from ep->ready_playback_urbs and in case there there aren't any available 282 * from ep->ready_playback_urbs and in case there there aren't any available
283 * or there are no packets that have been prepared, this function does 283 * or there are no packets that have been prepared, this function does
284 * nothing. 284 * nothing.
285 * 285 *
286 * The reason why the functionality of sending and preparing urbs is separated 286 * The reason why the functionality of sending and preparing urbs is separated
287 * is that host controllers don't guarantee an ordering in returing inbound 287 * is that host controllers don't guarantee an ordering in returing inbound
288 * and outbound packets to their submitters. 288 * and outbound packets to their submitters.
289 * 289 *
290 * This function is only used for implicit feedback endpoints. For endpoints 290 * This function is only used for implicit feedback endpoints. For endpoints
291 * driven by sync endpoints, urbs are submitted from their completion handler. 291 * driven by sync endpoints, urbs are submitted from their completion handler.
292 */ 292 */
293 static void queue_pending_output_urbs(struct snd_usb_endpoint *ep) 293 static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
294 { 294 {
295 while (test_bit(EP_FLAG_RUNNING, &ep->flags)) { 295 while (test_bit(EP_FLAG_RUNNING, &ep->flags)) {
296 296
297 unsigned long flags; 297 unsigned long flags;
298 struct snd_usb_packet_info *packet; 298 struct snd_usb_packet_info *uninitialized_var(packet);
299 struct snd_urb_ctx *ctx = NULL; 299 struct snd_urb_ctx *ctx = NULL;
300 struct urb *urb; 300 struct urb *urb;
301 int err, i; 301 int err, i;
302 302
303 spin_lock_irqsave(&ep->lock, flags); 303 spin_lock_irqsave(&ep->lock, flags);
304 if (ep->next_packet_read_pos != ep->next_packet_write_pos) { 304 if (ep->next_packet_read_pos != ep->next_packet_write_pos) {
305 packet = ep->next_packet + ep->next_packet_read_pos; 305 packet = ep->next_packet + ep->next_packet_read_pos;
306 ep->next_packet_read_pos++; 306 ep->next_packet_read_pos++;
307 ep->next_packet_read_pos %= MAX_URBS; 307 ep->next_packet_read_pos %= MAX_URBS;
308 308
309 /* take URB out of FIFO */ 309 /* take URB out of FIFO */
310 if (!list_empty(&ep->ready_playback_urbs)) 310 if (!list_empty(&ep->ready_playback_urbs))
311 ctx = list_first_entry(&ep->ready_playback_urbs, 311 ctx = list_first_entry(&ep->ready_playback_urbs,
312 struct snd_urb_ctx, ready_list); 312 struct snd_urb_ctx, ready_list);
313 } 313 }
314 spin_unlock_irqrestore(&ep->lock, flags); 314 spin_unlock_irqrestore(&ep->lock, flags);
315 315
316 if (ctx == NULL) 316 if (ctx == NULL)
317 return; 317 return;
318 318
319 list_del_init(&ctx->ready_list); 319 list_del_init(&ctx->ready_list);
320 urb = ctx->urb; 320 urb = ctx->urb;
321 321
322 /* copy over the length information */ 322 /* copy over the length information */
323 for (i = 0; i < packet->packets; i++) 323 for (i = 0; i < packet->packets; i++)
324 ctx->packet_size[i] = packet->packet_size[i]; 324 ctx->packet_size[i] = packet->packet_size[i];
325 325
326 /* call the data handler to fill in playback data */ 326 /* call the data handler to fill in playback data */
327 prepare_outbound_urb(ep, ctx); 327 prepare_outbound_urb(ep, ctx);
328 328
329 err = usb_submit_urb(ctx->urb, GFP_ATOMIC); 329 err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
330 if (err < 0) 330 if (err < 0)
331 snd_printk(KERN_ERR "Unable to submit urb #%d: %d (urb %p)\n", 331 snd_printk(KERN_ERR "Unable to submit urb #%d: %d (urb %p)\n",
332 ctx->index, err, ctx->urb); 332 ctx->index, err, ctx->urb);
333 else 333 else
334 set_bit(ctx->index, &ep->active_mask); 334 set_bit(ctx->index, &ep->active_mask);
335 } 335 }
336 } 336 }
337 337
338 /* 338 /*
339 * complete callback for urbs 339 * complete callback for urbs
340 */ 340 */
341 static void snd_complete_urb(struct urb *urb) 341 static void snd_complete_urb(struct urb *urb)
342 { 342 {
343 struct snd_urb_ctx *ctx = urb->context; 343 struct snd_urb_ctx *ctx = urb->context;
344 struct snd_usb_endpoint *ep = ctx->ep; 344 struct snd_usb_endpoint *ep = ctx->ep;
345 int err; 345 int err;
346 346
347 if (unlikely(urb->status == -ENOENT || /* unlinked */ 347 if (unlikely(urb->status == -ENOENT || /* unlinked */
348 urb->status == -ENODEV || /* device removed */ 348 urb->status == -ENODEV || /* device removed */
349 urb->status == -ECONNRESET || /* unlinked */ 349 urb->status == -ECONNRESET || /* unlinked */
350 urb->status == -ESHUTDOWN || /* device disabled */ 350 urb->status == -ESHUTDOWN || /* device disabled */
351 ep->chip->shutdown)) /* device disconnected */ 351 ep->chip->shutdown)) /* device disconnected */
352 goto exit_clear; 352 goto exit_clear;
353 353
354 if (usb_pipeout(ep->pipe)) { 354 if (usb_pipeout(ep->pipe)) {
355 retire_outbound_urb(ep, ctx); 355 retire_outbound_urb(ep, ctx);
356 /* can be stopped during retire callback */ 356 /* can be stopped during retire callback */
357 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags))) 357 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
358 goto exit_clear; 358 goto exit_clear;
359 359
360 if (snd_usb_endpoint_implict_feedback_sink(ep)) { 360 if (snd_usb_endpoint_implict_feedback_sink(ep)) {
361 unsigned long flags; 361 unsigned long flags;
362 362
363 spin_lock_irqsave(&ep->lock, flags); 363 spin_lock_irqsave(&ep->lock, flags);
364 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs); 364 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
365 spin_unlock_irqrestore(&ep->lock, flags); 365 spin_unlock_irqrestore(&ep->lock, flags);
366 queue_pending_output_urbs(ep); 366 queue_pending_output_urbs(ep);
367 367
368 goto exit_clear; 368 goto exit_clear;
369 } 369 }
370 370
371 prepare_outbound_urb_sizes(ep, ctx); 371 prepare_outbound_urb_sizes(ep, ctx);
372 prepare_outbound_urb(ep, ctx); 372 prepare_outbound_urb(ep, ctx);
373 } else { 373 } else {
374 retire_inbound_urb(ep, ctx); 374 retire_inbound_urb(ep, ctx);
375 /* can be stopped during retire callback */ 375 /* can be stopped during retire callback */
376 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags))) 376 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
377 goto exit_clear; 377 goto exit_clear;
378 378
379 prepare_inbound_urb(ep, ctx); 379 prepare_inbound_urb(ep, ctx);
380 } 380 }
381 381
382 err = usb_submit_urb(urb, GFP_ATOMIC); 382 err = usb_submit_urb(urb, GFP_ATOMIC);
383 if (err == 0) 383 if (err == 0)
384 return; 384 return;
385 385
386 snd_printk(KERN_ERR "cannot submit urb (err = %d)\n", err); 386 snd_printk(KERN_ERR "cannot submit urb (err = %d)\n", err);
387 //snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); 387 //snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
388 388
389 exit_clear: 389 exit_clear:
390 clear_bit(ctx->index, &ep->active_mask); 390 clear_bit(ctx->index, &ep->active_mask);
391 } 391 }
392 392
393 /** 393 /**
394 * snd_usb_add_endpoint: Add an endpoint to an audio chip 394 * snd_usb_add_endpoint: Add an endpoint to an audio chip
395 * 395 *
396 * @chip: The chip 396 * @chip: The chip
397 * @alts: The USB host interface 397 * @alts: The USB host interface
398 * @ep_num: The number of the endpoint to use 398 * @ep_num: The number of the endpoint to use
399 * @direction: SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE 399 * @direction: SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE
400 * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC 400 * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
401 * 401 *
402 * If the requested endpoint has not been added to the given chip before, 402 * If the requested endpoint has not been added to the given chip before,
403 * a new instance is created. Otherwise, a pointer to the previoulsy 403 * a new instance is created. Otherwise, a pointer to the previoulsy
404 * created instance is returned. In case of any error, NULL is returned. 404 * created instance is returned. In case of any error, NULL is returned.
405 * 405 *
406 * New endpoints will be added to chip->ep_list and must be freed by 406 * New endpoints will be added to chip->ep_list and must be freed by
407 * calling snd_usb_endpoint_free(). 407 * calling snd_usb_endpoint_free().
408 */ 408 */
409 struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip, 409 struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip,
410 struct usb_host_interface *alts, 410 struct usb_host_interface *alts,
411 int ep_num, int direction, int type) 411 int ep_num, int direction, int type)
412 { 412 {
413 struct list_head *p; 413 struct list_head *p;
414 struct snd_usb_endpoint *ep; 414 struct snd_usb_endpoint *ep;
415 int ret, is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK; 415 int ret, is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK;
416 416
417 mutex_lock(&chip->mutex); 417 mutex_lock(&chip->mutex);
418 418
419 list_for_each(p, &chip->ep_list) { 419 list_for_each(p, &chip->ep_list) {
420 ep = list_entry(p, struct snd_usb_endpoint, list); 420 ep = list_entry(p, struct snd_usb_endpoint, list);
421 if (ep->ep_num == ep_num && 421 if (ep->ep_num == ep_num &&
422 ep->iface == alts->desc.bInterfaceNumber && 422 ep->iface == alts->desc.bInterfaceNumber &&
423 ep->alt_idx == alts->desc.bAlternateSetting) { 423 ep->alt_idx == alts->desc.bAlternateSetting) {
424 snd_printdd(KERN_DEBUG "Re-using EP %x in iface %d,%d @%p\n", 424 snd_printdd(KERN_DEBUG "Re-using EP %x in iface %d,%d @%p\n",
425 ep_num, ep->iface, ep->alt_idx, ep); 425 ep_num, ep->iface, ep->alt_idx, ep);
426 goto __exit_unlock; 426 goto __exit_unlock;
427 } 427 }
428 } 428 }
429 429
430 snd_printdd(KERN_DEBUG "Creating new %s %s endpoint #%x\n", 430 snd_printdd(KERN_DEBUG "Creating new %s %s endpoint #%x\n",
431 is_playback ? "playback" : "capture", 431 is_playback ? "playback" : "capture",
432 type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync", 432 type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",
433 ep_num); 433 ep_num);
434 434
435 /* select the alt setting once so the endpoints become valid */ 435 /* select the alt setting once so the endpoints become valid */
436 ret = usb_set_interface(chip->dev, alts->desc.bInterfaceNumber, 436 ret = usb_set_interface(chip->dev, alts->desc.bInterfaceNumber,
437 alts->desc.bAlternateSetting); 437 alts->desc.bAlternateSetting);
438 if (ret < 0) { 438 if (ret < 0) {
439 snd_printk(KERN_ERR "%s(): usb_set_interface() failed, ret = %d\n", 439 snd_printk(KERN_ERR "%s(): usb_set_interface() failed, ret = %d\n",
440 __func__, ret); 440 __func__, ret);
441 ep = NULL; 441 ep = NULL;
442 goto __exit_unlock; 442 goto __exit_unlock;
443 } 443 }
444 444
445 ep = kzalloc(sizeof(*ep), GFP_KERNEL); 445 ep = kzalloc(sizeof(*ep), GFP_KERNEL);
446 if (!ep) 446 if (!ep)
447 goto __exit_unlock; 447 goto __exit_unlock;
448 448
449 ep->chip = chip; 449 ep->chip = chip;
450 spin_lock_init(&ep->lock); 450 spin_lock_init(&ep->lock);
451 ep->type = type; 451 ep->type = type;
452 ep->ep_num = ep_num; 452 ep->ep_num = ep_num;
453 ep->iface = alts->desc.bInterfaceNumber; 453 ep->iface = alts->desc.bInterfaceNumber;
454 ep->alt_idx = alts->desc.bAlternateSetting; 454 ep->alt_idx = alts->desc.bAlternateSetting;
455 INIT_LIST_HEAD(&ep->ready_playback_urbs); 455 INIT_LIST_HEAD(&ep->ready_playback_urbs);
456 ep_num &= USB_ENDPOINT_NUMBER_MASK; 456 ep_num &= USB_ENDPOINT_NUMBER_MASK;
457 457
458 if (is_playback) 458 if (is_playback)
459 ep->pipe = usb_sndisocpipe(chip->dev, ep_num); 459 ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
460 else 460 else
461 ep->pipe = usb_rcvisocpipe(chip->dev, ep_num); 461 ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
462 462
463 if (type == SND_USB_ENDPOINT_TYPE_SYNC) { 463 if (type == SND_USB_ENDPOINT_TYPE_SYNC) {
464 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && 464 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
465 get_endpoint(alts, 1)->bRefresh >= 1 && 465 get_endpoint(alts, 1)->bRefresh >= 1 &&
466 get_endpoint(alts, 1)->bRefresh <= 9) 466 get_endpoint(alts, 1)->bRefresh <= 9)
467 ep->syncinterval = get_endpoint(alts, 1)->bRefresh; 467 ep->syncinterval = get_endpoint(alts, 1)->bRefresh;
468 else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL) 468 else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
469 ep->syncinterval = 1; 469 ep->syncinterval = 1;
470 else if (get_endpoint(alts, 1)->bInterval >= 1 && 470 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
471 get_endpoint(alts, 1)->bInterval <= 16) 471 get_endpoint(alts, 1)->bInterval <= 16)
472 ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1; 472 ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
473 else 473 else
474 ep->syncinterval = 3; 474 ep->syncinterval = 3;
475 475
476 ep->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize); 476 ep->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize);
477 } 477 }
478 478
479 list_add_tail(&ep->list, &chip->ep_list); 479 list_add_tail(&ep->list, &chip->ep_list);
480 480
481 __exit_unlock: 481 __exit_unlock:
482 mutex_unlock(&chip->mutex); 482 mutex_unlock(&chip->mutex);
483 483
484 return ep; 484 return ep;
485 } 485 }
486 486
487 /* 487 /*
488 * wait until all urbs are processed. 488 * wait until all urbs are processed.
489 */ 489 */
490 static int wait_clear_urbs(struct snd_usb_endpoint *ep) 490 static int wait_clear_urbs(struct snd_usb_endpoint *ep)
491 { 491 {
492 unsigned long end_time = jiffies + msecs_to_jiffies(1000); 492 unsigned long end_time = jiffies + msecs_to_jiffies(1000);
493 unsigned int i; 493 unsigned int i;
494 int alive; 494 int alive;
495 495
496 do { 496 do {
497 alive = 0; 497 alive = 0;
498 for (i = 0; i < ep->nurbs; i++) 498 for (i = 0; i < ep->nurbs; i++)
499 if (test_bit(i, &ep->active_mask)) 499 if (test_bit(i, &ep->active_mask))
500 alive++; 500 alive++;
501 501
502 if (!alive) 502 if (!alive)
503 break; 503 break;
504 504
505 schedule_timeout_uninterruptible(1); 505 schedule_timeout_uninterruptible(1);
506 } while (time_before(jiffies, end_time)); 506 } while (time_before(jiffies, end_time));
507 507
508 if (alive) 508 if (alive)
509 snd_printk(KERN_ERR "timeout: still %d active urbs on EP #%x\n", 509 snd_printk(KERN_ERR "timeout: still %d active urbs on EP #%x\n",
510 alive, ep->ep_num); 510 alive, ep->ep_num);
511 511
512 return 0; 512 return 0;
513 } 513 }
514 514
515 /* 515 /*
516 * unlink active urbs. 516 * unlink active urbs.
517 */ 517 */
518 static int deactivate_urbs(struct snd_usb_endpoint *ep, int force, int can_sleep) 518 static int deactivate_urbs(struct snd_usb_endpoint *ep, int force, int can_sleep)
519 { 519 {
520 unsigned int i; 520 unsigned int i;
521 int async; 521 int async;
522 522
523 if (!force && ep->chip->shutdown) /* to be sure... */ 523 if (!force && ep->chip->shutdown) /* to be sure... */
524 return -EBADFD; 524 return -EBADFD;
525 525
526 async = !can_sleep && ep->chip->async_unlink; 526 async = !can_sleep && ep->chip->async_unlink;
527 527
528 clear_bit(EP_FLAG_RUNNING, &ep->flags); 528 clear_bit(EP_FLAG_RUNNING, &ep->flags);
529 529
530 INIT_LIST_HEAD(&ep->ready_playback_urbs); 530 INIT_LIST_HEAD(&ep->ready_playback_urbs);
531 ep->next_packet_read_pos = 0; 531 ep->next_packet_read_pos = 0;
532 ep->next_packet_write_pos = 0; 532 ep->next_packet_write_pos = 0;
533 533
534 if (!async && in_interrupt()) 534 if (!async && in_interrupt())
535 return 0; 535 return 0;
536 536
537 for (i = 0; i < ep->nurbs; i++) { 537 for (i = 0; i < ep->nurbs; i++) {
538 if (test_bit(i, &ep->active_mask)) { 538 if (test_bit(i, &ep->active_mask)) {
539 if (!test_and_set_bit(i, &ep->unlink_mask)) { 539 if (!test_and_set_bit(i, &ep->unlink_mask)) {
540 struct urb *u = ep->urb[i].urb; 540 struct urb *u = ep->urb[i].urb;
541 if (async) 541 if (async)
542 usb_unlink_urb(u); 542 usb_unlink_urb(u);
543 else 543 else
544 usb_kill_urb(u); 544 usb_kill_urb(u);
545 } 545 }
546 } 546 }
547 } 547 }
548 548
549 return 0; 549 return 0;
550 } 550 }
551 551
552 /* 552 /*
553 * release an endpoint's urbs 553 * release an endpoint's urbs
554 */ 554 */
555 static void release_urbs(struct snd_usb_endpoint *ep, int force) 555 static void release_urbs(struct snd_usb_endpoint *ep, int force)
556 { 556 {
557 int i; 557 int i;
558 558
559 /* route incoming urbs to nirvana */ 559 /* route incoming urbs to nirvana */
560 ep->retire_data_urb = NULL; 560 ep->retire_data_urb = NULL;
561 ep->prepare_data_urb = NULL; 561 ep->prepare_data_urb = NULL;
562 562
563 /* stop urbs */ 563 /* stop urbs */
564 deactivate_urbs(ep, force, 1); 564 deactivate_urbs(ep, force, 1);
565 wait_clear_urbs(ep); 565 wait_clear_urbs(ep);
566 566
567 for (i = 0; i < ep->nurbs; i++) 567 for (i = 0; i < ep->nurbs; i++)
568 release_urb_ctx(&ep->urb[i]); 568 release_urb_ctx(&ep->urb[i]);
569 569
570 if (ep->syncbuf) 570 if (ep->syncbuf)
571 usb_free_coherent(ep->chip->dev, SYNC_URBS * 4, 571 usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
572 ep->syncbuf, ep->sync_dma); 572 ep->syncbuf, ep->sync_dma);
573 573
574 ep->syncbuf = NULL; 574 ep->syncbuf = NULL;
575 ep->nurbs = 0; 575 ep->nurbs = 0;
576 } 576 }
577 577
578 /* 578 /*
579 * configure a data endpoint 579 * configure a data endpoint
580 */ 580 */
581 static int data_ep_set_params(struct snd_usb_endpoint *ep, 581 static int data_ep_set_params(struct snd_usb_endpoint *ep,
582 struct snd_pcm_hw_params *hw_params, 582 struct snd_pcm_hw_params *hw_params,
583 struct audioformat *fmt, 583 struct audioformat *fmt,
584 struct snd_usb_endpoint *sync_ep) 584 struct snd_usb_endpoint *sync_ep)
585 { 585 {
586 unsigned int maxsize, i, urb_packs, total_packs, packs_per_ms; 586 unsigned int maxsize, i, urb_packs, total_packs, packs_per_ms;
587 int period_bytes = params_period_bytes(hw_params); 587 int period_bytes = params_period_bytes(hw_params);
588 int format = params_format(hw_params); 588 int format = params_format(hw_params);
589 int is_playback = usb_pipeout(ep->pipe); 589 int is_playback = usb_pipeout(ep->pipe);
590 int frame_bits = snd_pcm_format_physical_width(params_format(hw_params)) * 590 int frame_bits = snd_pcm_format_physical_width(params_format(hw_params)) *
591 params_channels(hw_params); 591 params_channels(hw_params);
592 592
593 ep->datainterval = fmt->datainterval; 593 ep->datainterval = fmt->datainterval;
594 ep->stride = frame_bits >> 3; 594 ep->stride = frame_bits >> 3;
595 ep->silence_value = format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0; 595 ep->silence_value = format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0;
596 596
597 /* calculate max. frequency */ 597 /* calculate max. frequency */
598 if (ep->maxpacksize) { 598 if (ep->maxpacksize) {
599 /* whatever fits into a max. size packet */ 599 /* whatever fits into a max. size packet */
600 maxsize = ep->maxpacksize; 600 maxsize = ep->maxpacksize;
601 ep->freqmax = (maxsize / (frame_bits >> 3)) 601 ep->freqmax = (maxsize / (frame_bits >> 3))
602 << (16 - ep->datainterval); 602 << (16 - ep->datainterval);
603 } else { 603 } else {
604 /* no max. packet size: just take 25% higher than nominal */ 604 /* no max. packet size: just take 25% higher than nominal */
605 ep->freqmax = ep->freqn + (ep->freqn >> 2); 605 ep->freqmax = ep->freqn + (ep->freqn >> 2);
606 maxsize = ((ep->freqmax + 0xffff) * (frame_bits >> 3)) 606 maxsize = ((ep->freqmax + 0xffff) * (frame_bits >> 3))
607 >> (16 - ep->datainterval); 607 >> (16 - ep->datainterval);
608 } 608 }
609 609
610 if (ep->fill_max) 610 if (ep->fill_max)
611 ep->curpacksize = ep->maxpacksize; 611 ep->curpacksize = ep->maxpacksize;
612 else 612 else
613 ep->curpacksize = maxsize; 613 ep->curpacksize = maxsize;
614 614
615 if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL) 615 if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL)
616 packs_per_ms = 8 >> ep->datainterval; 616 packs_per_ms = 8 >> ep->datainterval;
617 else 617 else
618 packs_per_ms = 1; 618 packs_per_ms = 1;
619 619
620 if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) { 620 if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
621 urb_packs = max(ep->chip->nrpacks, 1); 621 urb_packs = max(ep->chip->nrpacks, 1);
622 urb_packs = min(urb_packs, (unsigned int) MAX_PACKS); 622 urb_packs = min(urb_packs, (unsigned int) MAX_PACKS);
623 } else { 623 } else {
624 urb_packs = 1; 624 urb_packs = 1;
625 } 625 }
626 626
627 urb_packs *= packs_per_ms; 627 urb_packs *= packs_per_ms;
628 628
629 if (sync_ep && !snd_usb_endpoint_implict_feedback_sink(ep)) 629 if (sync_ep && !snd_usb_endpoint_implict_feedback_sink(ep))
630 urb_packs = min(urb_packs, 1U << sync_ep->syncinterval); 630 urb_packs = min(urb_packs, 1U << sync_ep->syncinterval);
631 631
632 /* decide how many packets to be used */ 632 /* decide how many packets to be used */
633 if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) { 633 if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
634 unsigned int minsize, maxpacks; 634 unsigned int minsize, maxpacks;
635 /* determine how small a packet can be */ 635 /* determine how small a packet can be */
636 minsize = (ep->freqn >> (16 - ep->datainterval)) 636 minsize = (ep->freqn >> (16 - ep->datainterval))
637 * (frame_bits >> 3); 637 * (frame_bits >> 3);
638 /* with sync from device, assume it can be 12% lower */ 638 /* with sync from device, assume it can be 12% lower */
639 if (sync_ep) 639 if (sync_ep)
640 minsize -= minsize >> 3; 640 minsize -= minsize >> 3;
641 minsize = max(minsize, 1u); 641 minsize = max(minsize, 1u);
642 total_packs = (period_bytes + minsize - 1) / minsize; 642 total_packs = (period_bytes + minsize - 1) / minsize;
643 /* we need at least two URBs for queueing */ 643 /* we need at least two URBs for queueing */
644 if (total_packs < 2) { 644 if (total_packs < 2) {
645 total_packs = 2; 645 total_packs = 2;
646 } else { 646 } else {
647 /* and we don't want too long a queue either */ 647 /* and we don't want too long a queue either */
648 maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2); 648 maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
649 total_packs = min(total_packs, maxpacks); 649 total_packs = min(total_packs, maxpacks);
650 } 650 }
651 } else { 651 } else {
652 while (urb_packs > 1 && urb_packs * maxsize >= period_bytes) 652 while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
653 urb_packs >>= 1; 653 urb_packs >>= 1;
654 total_packs = MAX_URBS * urb_packs; 654 total_packs = MAX_URBS * urb_packs;
655 } 655 }
656 656
657 ep->nurbs = (total_packs + urb_packs - 1) / urb_packs; 657 ep->nurbs = (total_packs + urb_packs - 1) / urb_packs;
658 if (ep->nurbs > MAX_URBS) { 658 if (ep->nurbs > MAX_URBS) {
659 /* too much... */ 659 /* too much... */
660 ep->nurbs = MAX_URBS; 660 ep->nurbs = MAX_URBS;
661 total_packs = MAX_URBS * urb_packs; 661 total_packs = MAX_URBS * urb_packs;
662 } else if (ep->nurbs < 2) { 662 } else if (ep->nurbs < 2) {
663 /* too little - we need at least two packets 663 /* too little - we need at least two packets
664 * to ensure contiguous playback/capture 664 * to ensure contiguous playback/capture
665 */ 665 */
666 ep->nurbs = 2; 666 ep->nurbs = 2;
667 } 667 }
668 668
669 /* allocate and initialize data urbs */ 669 /* allocate and initialize data urbs */
670 for (i = 0; i < ep->nurbs; i++) { 670 for (i = 0; i < ep->nurbs; i++) {
671 struct snd_urb_ctx *u = &ep->urb[i]; 671 struct snd_urb_ctx *u = &ep->urb[i];
672 u->index = i; 672 u->index = i;
673 u->ep = ep; 673 u->ep = ep;
674 u->packets = (i + 1) * total_packs / ep->nurbs 674 u->packets = (i + 1) * total_packs / ep->nurbs
675 - i * total_packs / ep->nurbs; 675 - i * total_packs / ep->nurbs;
676 u->buffer_size = maxsize * u->packets; 676 u->buffer_size = maxsize * u->packets;
677 677
678 if (fmt->fmt_type == UAC_FORMAT_TYPE_II) 678 if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
679 u->packets++; /* for transfer delimiter */ 679 u->packets++; /* for transfer delimiter */
680 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL); 680 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
681 if (!u->urb) 681 if (!u->urb)
682 goto out_of_memory; 682 goto out_of_memory;
683 683
684 u->urb->transfer_buffer = 684 u->urb->transfer_buffer =
685 usb_alloc_coherent(ep->chip->dev, u->buffer_size, 685 usb_alloc_coherent(ep->chip->dev, u->buffer_size,
686 GFP_KERNEL, &u->urb->transfer_dma); 686 GFP_KERNEL, &u->urb->transfer_dma);
687 if (!u->urb->transfer_buffer) 687 if (!u->urb->transfer_buffer)
688 goto out_of_memory; 688 goto out_of_memory;
689 u->urb->pipe = ep->pipe; 689 u->urb->pipe = ep->pipe;
690 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 690 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
691 u->urb->interval = 1 << ep->datainterval; 691 u->urb->interval = 1 << ep->datainterval;
692 u->urb->context = u; 692 u->urb->context = u;
693 u->urb->complete = snd_complete_urb; 693 u->urb->complete = snd_complete_urb;
694 INIT_LIST_HEAD(&u->ready_list); 694 INIT_LIST_HEAD(&u->ready_list);
695 } 695 }
696 696
697 return 0; 697 return 0;
698 698
699 out_of_memory: 699 out_of_memory:
700 release_urbs(ep, 0); 700 release_urbs(ep, 0);
701 return -ENOMEM; 701 return -ENOMEM;
702 } 702 }
703 703
704 /* 704 /*
705 * configure a sync endpoint 705 * configure a sync endpoint
706 */ 706 */
707 static int sync_ep_set_params(struct snd_usb_endpoint *ep, 707 static int sync_ep_set_params(struct snd_usb_endpoint *ep,
708 struct snd_pcm_hw_params *hw_params, 708 struct snd_pcm_hw_params *hw_params,
709 struct audioformat *fmt) 709 struct audioformat *fmt)
710 { 710 {
711 int i; 711 int i;
712 712
713 ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4, 713 ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4,
714 GFP_KERNEL, &ep->sync_dma); 714 GFP_KERNEL, &ep->sync_dma);
715 if (!ep->syncbuf) 715 if (!ep->syncbuf)
716 return -ENOMEM; 716 return -ENOMEM;
717 717
718 for (i = 0; i < SYNC_URBS; i++) { 718 for (i = 0; i < SYNC_URBS; i++) {
719 struct snd_urb_ctx *u = &ep->urb[i]; 719 struct snd_urb_ctx *u = &ep->urb[i];
720 u->index = i; 720 u->index = i;
721 u->ep = ep; 721 u->ep = ep;
722 u->packets = 1; 722 u->packets = 1;
723 u->urb = usb_alloc_urb(1, GFP_KERNEL); 723 u->urb = usb_alloc_urb(1, GFP_KERNEL);
724 if (!u->urb) 724 if (!u->urb)
725 goto out_of_memory; 725 goto out_of_memory;
726 u->urb->transfer_buffer = ep->syncbuf + i * 4; 726 u->urb->transfer_buffer = ep->syncbuf + i * 4;
727 u->urb->transfer_dma = ep->sync_dma + i * 4; 727 u->urb->transfer_dma = ep->sync_dma + i * 4;
728 u->urb->transfer_buffer_length = 4; 728 u->urb->transfer_buffer_length = 4;
729 u->urb->pipe = ep->pipe; 729 u->urb->pipe = ep->pipe;
730 u->urb->transfer_flags = URB_ISO_ASAP | 730 u->urb->transfer_flags = URB_ISO_ASAP |
731 URB_NO_TRANSFER_DMA_MAP; 731 URB_NO_TRANSFER_DMA_MAP;
732 u->urb->number_of_packets = 1; 732 u->urb->number_of_packets = 1;
733 u->urb->interval = 1 << ep->syncinterval; 733 u->urb->interval = 1 << ep->syncinterval;
734 u->urb->context = u; 734 u->urb->context = u;
735 u->urb->complete = snd_complete_urb; 735 u->urb->complete = snd_complete_urb;
736 } 736 }
737 737
738 ep->nurbs = SYNC_URBS; 738 ep->nurbs = SYNC_URBS;
739 739
740 return 0; 740 return 0;
741 741
742 out_of_memory: 742 out_of_memory:
743 release_urbs(ep, 0); 743 release_urbs(ep, 0);
744 return -ENOMEM; 744 return -ENOMEM;
745 } 745 }
746 746
747 /** 747 /**
748 * snd_usb_endpoint_set_params: configure an snd_endpoint 748 * snd_usb_endpoint_set_params: configure an snd_endpoint
749 * 749 *
750 * @ep: the endpoint to configure 750 * @ep: the endpoint to configure
751 * 751 *
752 * Determine the number of of URBs to be used on this endpoint. 752 * Determine the number of of URBs to be used on this endpoint.
753 * An endpoint must be configured before it can be started. 753 * An endpoint must be configured before it can be started.
754 * An endpoint that is already running can not be reconfigured. 754 * An endpoint that is already running can not be reconfigured.
755 */ 755 */
756 int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep, 756 int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
757 struct snd_pcm_hw_params *hw_params, 757 struct snd_pcm_hw_params *hw_params,
758 struct audioformat *fmt, 758 struct audioformat *fmt,
759 struct snd_usb_endpoint *sync_ep) 759 struct snd_usb_endpoint *sync_ep)
760 { 760 {
761 int err; 761 int err;
762 762
763 if (ep->use_count != 0) { 763 if (ep->use_count != 0) {
764 snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n", 764 snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n",
765 ep->ep_num); 765 ep->ep_num);
766 return -EBUSY; 766 return -EBUSY;
767 } 767 }
768 768
769 /* release old buffers, if any */ 769 /* release old buffers, if any */
770 release_urbs(ep, 0); 770 release_urbs(ep, 0);
771 771
772 ep->datainterval = fmt->datainterval; 772 ep->datainterval = fmt->datainterval;
773 ep->maxpacksize = fmt->maxpacksize; 773 ep->maxpacksize = fmt->maxpacksize;
774 ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX); 774 ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
775 775
776 if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL) 776 if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL)
777 ep->freqn = get_usb_full_speed_rate(params_rate(hw_params)); 777 ep->freqn = get_usb_full_speed_rate(params_rate(hw_params));
778 else 778 else
779 ep->freqn = get_usb_high_speed_rate(params_rate(hw_params)); 779 ep->freqn = get_usb_high_speed_rate(params_rate(hw_params));
780 780
781 /* calculate the frequency in 16.16 format */ 781 /* calculate the frequency in 16.16 format */
782 ep->freqm = ep->freqn; 782 ep->freqm = ep->freqn;
783 ep->freqshift = INT_MIN; 783 ep->freqshift = INT_MIN;
784 784
785 ep->phase = 0; 785 ep->phase = 0;
786 786
787 switch (ep->type) { 787 switch (ep->type) {
788 case SND_USB_ENDPOINT_TYPE_DATA: 788 case SND_USB_ENDPOINT_TYPE_DATA:
789 err = data_ep_set_params(ep, hw_params, fmt, sync_ep); 789 err = data_ep_set_params(ep, hw_params, fmt, sync_ep);
790 break; 790 break;
791 case SND_USB_ENDPOINT_TYPE_SYNC: 791 case SND_USB_ENDPOINT_TYPE_SYNC:
792 err = sync_ep_set_params(ep, hw_params, fmt); 792 err = sync_ep_set_params(ep, hw_params, fmt);
793 break; 793 break;
794 default: 794 default:
795 err = -EINVAL; 795 err = -EINVAL;
796 } 796 }
797 797
798 snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n", 798 snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
799 ep->ep_num, ep->type, ep->nurbs, err); 799 ep->ep_num, ep->type, ep->nurbs, err);
800 800
801 return err; 801 return err;
802 } 802 }
803 803
804 /** 804 /**
805 * snd_usb_endpoint_start: start an snd_usb_endpoint 805 * snd_usb_endpoint_start: start an snd_usb_endpoint
806 * 806 *
807 * @ep: the endpoint to start 807 * @ep: the endpoint to start
808 * 808 *
809 * A call to this function will increment the use count of the endpoint. 809 * A call to this function will increment the use count of the endpoint.
810 * In case this not already running, the URBs for this endpoint will be 810 * In case this not already running, the URBs for this endpoint will be
811 * submitted. Otherwise, this function does nothing. 811 * submitted. Otherwise, this function does nothing.
812 * 812 *
813 * Must be balanced to calls of snd_usb_endpoint_stop(). 813 * Must be balanced to calls of snd_usb_endpoint_stop().
814 * 814 *
815 * Returns an error if the URB submission failed, 0 in all other cases. 815 * Returns an error if the URB submission failed, 0 in all other cases.
816 */ 816 */
817 int snd_usb_endpoint_start(struct snd_usb_endpoint *ep) 817 int snd_usb_endpoint_start(struct snd_usb_endpoint *ep)
818 { 818 {
819 int err; 819 int err;
820 unsigned int i; 820 unsigned int i;
821 821
822 if (ep->chip->shutdown) 822 if (ep->chip->shutdown)
823 return -EBADFD; 823 return -EBADFD;
824 824
825 /* already running? */ 825 /* already running? */
826 if (++ep->use_count != 1) 826 if (++ep->use_count != 1)
827 return 0; 827 return 0;
828 828
829 if (snd_BUG_ON(!test_bit(EP_FLAG_ACTIVATED, &ep->flags))) 829 if (snd_BUG_ON(!test_bit(EP_FLAG_ACTIVATED, &ep->flags)))
830 return -EINVAL; 830 return -EINVAL;
831 831
832 /* just to be sure */ 832 /* just to be sure */
833 deactivate_urbs(ep, 0, 1); 833 deactivate_urbs(ep, 0, 1);
834 wait_clear_urbs(ep); 834 wait_clear_urbs(ep);
835 835
836 ep->active_mask = 0; 836 ep->active_mask = 0;
837 ep->unlink_mask = 0; 837 ep->unlink_mask = 0;
838 ep->phase = 0; 838 ep->phase = 0;
839 839
840 /* 840 /*
841 * If this endpoint has a data endpoint as implicit feedback source, 841 * If this endpoint has a data endpoint as implicit feedback source,
842 * don't start the urbs here. Instead, mark them all as available, 842 * don't start the urbs here. Instead, mark them all as available,
843 * wait for the record urbs to arrive and queue from that context. 843 * wait for the record urbs to arrive and queue from that context.
844 */ 844 */
845 845
846 set_bit(EP_FLAG_RUNNING, &ep->flags); 846 set_bit(EP_FLAG_RUNNING, &ep->flags);
847 847
848 if (snd_usb_endpoint_implict_feedback_sink(ep)) { 848 if (snd_usb_endpoint_implict_feedback_sink(ep)) {
849 for (i = 0; i < ep->nurbs; i++) { 849 for (i = 0; i < ep->nurbs; i++) {
850 struct snd_urb_ctx *ctx = ep->urb + i; 850 struct snd_urb_ctx *ctx = ep->urb + i;
851 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs); 851 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
852 } 852 }
853 853
854 return 0; 854 return 0;
855 } 855 }
856 856
857 for (i = 0; i < ep->nurbs; i++) { 857 for (i = 0; i < ep->nurbs; i++) {
858 struct urb *urb = ep->urb[i].urb; 858 struct urb *urb = ep->urb[i].urb;
859 859
860 if (snd_BUG_ON(!urb)) 860 if (snd_BUG_ON(!urb))
861 goto __error; 861 goto __error;
862 862
863 if (usb_pipeout(ep->pipe)) { 863 if (usb_pipeout(ep->pipe)) {
864 prepare_outbound_urb_sizes(ep, urb->context); 864 prepare_outbound_urb_sizes(ep, urb->context);
865 prepare_outbound_urb(ep, urb->context); 865 prepare_outbound_urb(ep, urb->context);
866 } else { 866 } else {
867 prepare_inbound_urb(ep, urb->context); 867 prepare_inbound_urb(ep, urb->context);
868 } 868 }
869 869
870 err = usb_submit_urb(urb, GFP_ATOMIC); 870 err = usb_submit_urb(urb, GFP_ATOMIC);
871 if (err < 0) { 871 if (err < 0) {
872 snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n", 872 snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n",
873 i, err, usb_error_string(err)); 873 i, err, usb_error_string(err));
874 goto __error; 874 goto __error;
875 } 875 }
876 set_bit(i, &ep->active_mask); 876 set_bit(i, &ep->active_mask);
877 } 877 }
878 878
879 return 0; 879 return 0;
880 880
881 __error: 881 __error:
882 clear_bit(EP_FLAG_RUNNING, &ep->flags); 882 clear_bit(EP_FLAG_RUNNING, &ep->flags);
883 ep->use_count--; 883 ep->use_count--;
884 deactivate_urbs(ep, 0, 0); 884 deactivate_urbs(ep, 0, 0);
885 return -EPIPE; 885 return -EPIPE;
886 } 886 }
887 887
888 /** 888 /**
889 * snd_usb_endpoint_stop: stop an snd_usb_endpoint 889 * snd_usb_endpoint_stop: stop an snd_usb_endpoint
890 * 890 *
891 * @ep: the endpoint to stop (may be NULL) 891 * @ep: the endpoint to stop (may be NULL)
892 * 892 *
893 * A call to this function will decrement the use count of the endpoint. 893 * A call to this function will decrement the use count of the endpoint.
894 * In case the last user has requested the endpoint stop, the URBs will 894 * In case the last user has requested the endpoint stop, the URBs will
895 * actually deactivated. 895 * actually deactivated.
896 * 896 *
897 * Must be balanced to calls of snd_usb_endpoint_start(). 897 * Must be balanced to calls of snd_usb_endpoint_start().
898 */ 898 */
899 void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep, 899 void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep,
900 int force, int can_sleep, int wait) 900 int force, int can_sleep, int wait)
901 { 901 {
902 if (!ep) 902 if (!ep)
903 return; 903 return;
904 904
905 if (snd_BUG_ON(ep->use_count == 0)) 905 if (snd_BUG_ON(ep->use_count == 0))
906 return; 906 return;
907 907
908 if (snd_BUG_ON(!test_bit(EP_FLAG_ACTIVATED, &ep->flags))) 908 if (snd_BUG_ON(!test_bit(EP_FLAG_ACTIVATED, &ep->flags)))
909 return; 909 return;
910 910
911 if (--ep->use_count == 0) { 911 if (--ep->use_count == 0) {
912 deactivate_urbs(ep, force, can_sleep); 912 deactivate_urbs(ep, force, can_sleep);
913 ep->data_subs = NULL; 913 ep->data_subs = NULL;
914 ep->sync_slave = NULL; 914 ep->sync_slave = NULL;
915 ep->retire_data_urb = NULL; 915 ep->retire_data_urb = NULL;
916 ep->prepare_data_urb = NULL; 916 ep->prepare_data_urb = NULL;
917 917
918 if (wait) 918 if (wait)
919 wait_clear_urbs(ep); 919 wait_clear_urbs(ep);
920 } 920 }
921 } 921 }
922 922
923 /** 923 /**
924 * snd_usb_endpoint_activate: activate an snd_usb_endpoint 924 * snd_usb_endpoint_activate: activate an snd_usb_endpoint
925 * 925 *
926 * @ep: the endpoint to activate 926 * @ep: the endpoint to activate
927 * 927 *
928 * If the endpoint is not currently in use, this functions will select the 928 * If the endpoint is not currently in use, this functions will select the
929 * correct alternate interface setting for the interface of this endpoint. 929 * correct alternate interface setting for the interface of this endpoint.
930 * 930 *
931 * In case of any active users, this functions does nothing. 931 * In case of any active users, this functions does nothing.
932 * 932 *
933 * Returns an error if usb_set_interface() failed, 0 in all other 933 * Returns an error if usb_set_interface() failed, 0 in all other
934 * cases. 934 * cases.
935 */ 935 */
936 int snd_usb_endpoint_activate(struct snd_usb_endpoint *ep) 936 int snd_usb_endpoint_activate(struct snd_usb_endpoint *ep)
937 { 937 {
938 if (ep->use_count != 0) 938 if (ep->use_count != 0)
939 return 0; 939 return 0;
940 940
941 if (!ep->chip->shutdown && 941 if (!ep->chip->shutdown &&
942 !test_and_set_bit(EP_FLAG_ACTIVATED, &ep->flags)) { 942 !test_and_set_bit(EP_FLAG_ACTIVATED, &ep->flags)) {
943 int ret; 943 int ret;
944 944
945 ret = usb_set_interface(ep->chip->dev, ep->iface, ep->alt_idx); 945 ret = usb_set_interface(ep->chip->dev, ep->iface, ep->alt_idx);
946 if (ret < 0) { 946 if (ret < 0) {
947 snd_printk(KERN_ERR "%s() usb_set_interface() failed, ret = %d\n", 947 snd_printk(KERN_ERR "%s() usb_set_interface() failed, ret = %d\n",
948 __func__, ret); 948 __func__, ret);
949 clear_bit(EP_FLAG_ACTIVATED, &ep->flags); 949 clear_bit(EP_FLAG_ACTIVATED, &ep->flags);
950 return ret; 950 return ret;
951 } 951 }
952 952
953 return 0; 953 return 0;
954 } 954 }
955 955
956 return -EBUSY; 956 return -EBUSY;
957 } 957 }
958 958
959 /** 959 /**
960 * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint 960 * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint
961 * 961 *
962 * @ep: the endpoint to deactivate 962 * @ep: the endpoint to deactivate
963 * 963 *
964 * If the endpoint is not currently in use, this functions will select the 964 * If the endpoint is not currently in use, this functions will select the
965 * alternate interface setting 0 for the interface of this endpoint. 965 * alternate interface setting 0 for the interface of this endpoint.
966 * 966 *
967 * In case of any active users, this functions does nothing. 967 * In case of any active users, this functions does nothing.
968 * 968 *
969 * Returns an error if usb_set_interface() failed, 0 in all other 969 * Returns an error if usb_set_interface() failed, 0 in all other
970 * cases. 970 * cases.
971 */ 971 */
972 int snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep) 972 int snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep)
973 { 973 {
974 if (!ep) 974 if (!ep)
975 return -EINVAL; 975 return -EINVAL;
976 976
977 if (ep->use_count != 0) 977 if (ep->use_count != 0)
978 return 0; 978 return 0;
979 979
980 if (!ep->chip->shutdown && 980 if (!ep->chip->shutdown &&
981 test_and_clear_bit(EP_FLAG_ACTIVATED, &ep->flags)) { 981 test_and_clear_bit(EP_FLAG_ACTIVATED, &ep->flags)) {
982 int ret; 982 int ret;
983 983
984 ret = usb_set_interface(ep->chip->dev, ep->iface, 0); 984 ret = usb_set_interface(ep->chip->dev, ep->iface, 0);
985 if (ret < 0) { 985 if (ret < 0) {
986 snd_printk(KERN_ERR "%s(): usb_set_interface() failed, ret = %d\n", 986 snd_printk(KERN_ERR "%s(): usb_set_interface() failed, ret = %d\n",
987 __func__, ret); 987 __func__, ret);
988 return ret; 988 return ret;
989 } 989 }
990 990
991 return 0; 991 return 0;
992 } 992 }
993 993
994 return -EBUSY; 994 return -EBUSY;
995 } 995 }
996 996
997 /** snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint 997 /** snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint
998 * 998 *
999 * @ep: the list header of the endpoint to free 999 * @ep: the list header of the endpoint to free
1000 * 1000 *
1001 * This function does not care for the endpoint's use count but will tear 1001 * This function does not care for the endpoint's use count but will tear
1002 * down all the streaming URBs immediately and free all resources. 1002 * down all the streaming URBs immediately and free all resources.
1003 */ 1003 */
1004 void snd_usb_endpoint_free(struct list_head *head) 1004 void snd_usb_endpoint_free(struct list_head *head)
1005 { 1005 {
1006 struct snd_usb_endpoint *ep; 1006 struct snd_usb_endpoint *ep;
1007 1007
1008 ep = list_entry(head, struct snd_usb_endpoint, list); 1008 ep = list_entry(head, struct snd_usb_endpoint, list);
1009 release_urbs(ep, 1); 1009 release_urbs(ep, 1);
1010 kfree(ep); 1010 kfree(ep);
1011 } 1011 }
1012 1012
1013 /** 1013 /**
1014 * snd_usb_handle_sync_urb: parse an USB sync packet 1014 * snd_usb_handle_sync_urb: parse an USB sync packet
1015 * 1015 *
1016 * @ep: the endpoint to handle the packet 1016 * @ep: the endpoint to handle the packet
1017 * @sender: the sending endpoint 1017 * @sender: the sending endpoint
1018 * @urb: the received packet 1018 * @urb: the received packet
1019 * 1019 *
1020 * This function is called from the context of an endpoint that received 1020 * This function is called from the context of an endpoint that received
1021 * the packet and is used to let another endpoint object handle the payload. 1021 * the packet and is used to let another endpoint object handle the payload.
1022 */ 1022 */
1023 void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep, 1023 void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
1024 struct snd_usb_endpoint *sender, 1024 struct snd_usb_endpoint *sender,
1025 const struct urb *urb) 1025 const struct urb *urb)
1026 { 1026 {
1027 int shift; 1027 int shift;
1028 unsigned int f; 1028 unsigned int f;
1029 unsigned long flags; 1029 unsigned long flags;
1030 1030
1031 snd_BUG_ON(ep == sender); 1031 snd_BUG_ON(ep == sender);
1032 1032
1033 /* 1033 /*
1034 * In case the endpoint is operating in implicit feedback mode, prepare 1034 * In case the endpoint is operating in implicit feedback mode, prepare
1035 * and a new outbound URB that has the same layout as the received 1035 * and a new outbound URB that has the same layout as the received
1036 * packet and add it to the list of pending urbs. 1036 * packet and add it to the list of pending urbs.
1037 */ 1037 */
1038 if (snd_usb_endpoint_implict_feedback_sink(ep) && 1038 if (snd_usb_endpoint_implict_feedback_sink(ep) &&
1039 ep->use_count != 0) { 1039 ep->use_count != 0) {
1040 1040
1041 /* implicit feedback case */ 1041 /* implicit feedback case */
1042 int i, bytes = 0; 1042 int i, bytes = 0;
1043 struct snd_urb_ctx *in_ctx; 1043 struct snd_urb_ctx *in_ctx;
1044 struct snd_usb_packet_info *out_packet; 1044 struct snd_usb_packet_info *out_packet;
1045 1045
1046 in_ctx = urb->context; 1046 in_ctx = urb->context;
1047 1047
1048 /* Count overall packet size */ 1048 /* Count overall packet size */
1049 for (i = 0; i < in_ctx->packets; i++) 1049 for (i = 0; i < in_ctx->packets; i++)
1050 if (urb->iso_frame_desc[i].status == 0) 1050 if (urb->iso_frame_desc[i].status == 0)
1051 bytes += urb->iso_frame_desc[i].actual_length; 1051 bytes += urb->iso_frame_desc[i].actual_length;
1052 1052
1053 /* 1053 /*
1054 * skip empty packets. At least M-Audio's Fast Track Ultra stops 1054 * skip empty packets. At least M-Audio's Fast Track Ultra stops
1055 * streaming once it received a 0-byte OUT URB 1055 * streaming once it received a 0-byte OUT URB
1056 */ 1056 */
1057 if (bytes == 0) 1057 if (bytes == 0)
1058 return; 1058 return;
1059 1059
1060 spin_lock_irqsave(&ep->lock, flags); 1060 spin_lock_irqsave(&ep->lock, flags);
1061 out_packet = ep->next_packet + ep->next_packet_write_pos; 1061 out_packet = ep->next_packet + ep->next_packet_write_pos;
1062 1062
1063 /* 1063 /*
1064 * Iterate through the inbound packet and prepare the lengths 1064 * Iterate through the inbound packet and prepare the lengths
1065 * for the output packet. The OUT packet we are about to send 1065 * for the output packet. The OUT packet we are about to send
1066 * will have the same amount of payload than the IN packet we 1066 * will have the same amount of payload than the IN packet we
1067 * just received. 1067 * just received.
1068 */ 1068 */
1069 1069
1070 out_packet->packets = in_ctx->packets; 1070 out_packet->packets = in_ctx->packets;
1071 for (i = 0; i < in_ctx->packets; i++) { 1071 for (i = 0; i < in_ctx->packets; i++) {
1072 if (urb->iso_frame_desc[i].status == 0) 1072 if (urb->iso_frame_desc[i].status == 0)
1073 out_packet->packet_size[i] = 1073 out_packet->packet_size[i] =
1074 urb->iso_frame_desc[i].actual_length / ep->stride; 1074 urb->iso_frame_desc[i].actual_length / ep->stride;
1075 else 1075 else
1076 out_packet->packet_size[i] = 0; 1076 out_packet->packet_size[i] = 0;
1077 } 1077 }
1078 1078
1079 ep->next_packet_write_pos++; 1079 ep->next_packet_write_pos++;
1080 ep->next_packet_write_pos %= MAX_URBS; 1080 ep->next_packet_write_pos %= MAX_URBS;
1081 spin_unlock_irqrestore(&ep->lock, flags); 1081 spin_unlock_irqrestore(&ep->lock, flags);
1082 queue_pending_output_urbs(ep); 1082 queue_pending_output_urbs(ep);
1083 1083
1084 return; 1084 return;
1085 } 1085 }
1086 1086
1087 /* 1087 /*
1088 * process after playback sync complete 1088 * process after playback sync complete
1089 * 1089 *
1090 * Full speed devices report feedback values in 10.14 format as samples 1090 * Full speed devices report feedback values in 10.14 format as samples
1091 * per frame, high speed devices in 16.16 format as samples per 1091 * per frame, high speed devices in 16.16 format as samples per
1092 * microframe. 1092 * microframe.
1093 * 1093 *
1094 * Because the Audio Class 1 spec was written before USB 2.0, many high 1094 * Because the Audio Class 1 spec was written before USB 2.0, many high
1095 * speed devices use a wrong interpretation, some others use an 1095 * speed devices use a wrong interpretation, some others use an
1096 * entirely different format. 1096 * entirely different format.
1097 * 1097 *
1098 * Therefore, we cannot predict what format any particular device uses 1098 * Therefore, we cannot predict what format any particular device uses
1099 * and must detect it automatically. 1099 * and must detect it automatically.
1100 */ 1100 */
1101 1101
1102 if (urb->iso_frame_desc[0].status != 0 || 1102 if (urb->iso_frame_desc[0].status != 0 ||
1103 urb->iso_frame_desc[0].actual_length < 3) 1103 urb->iso_frame_desc[0].actual_length < 3)
1104 return; 1104 return;
1105 1105
1106 f = le32_to_cpup(urb->transfer_buffer); 1106 f = le32_to_cpup(urb->transfer_buffer);
1107 if (urb->iso_frame_desc[0].actual_length == 3) 1107 if (urb->iso_frame_desc[0].actual_length == 3)
1108 f &= 0x00ffffff; 1108 f &= 0x00ffffff;
1109 else 1109 else
1110 f &= 0x0fffffff; 1110 f &= 0x0fffffff;
1111 1111
1112 if (f == 0) 1112 if (f == 0)
1113 return; 1113 return;
1114 1114
1115 if (unlikely(ep->freqshift == INT_MIN)) { 1115 if (unlikely(ep->freqshift == INT_MIN)) {
1116 /* 1116 /*
1117 * The first time we see a feedback value, determine its format 1117 * The first time we see a feedback value, determine its format
1118 * by shifting it left or right until it matches the nominal 1118 * by shifting it left or right until it matches the nominal
1119 * frequency value. This assumes that the feedback does not 1119 * frequency value. This assumes that the feedback does not
1120 * differ from the nominal value more than +50% or -25%. 1120 * differ from the nominal value more than +50% or -25%.
1121 */ 1121 */
1122 shift = 0; 1122 shift = 0;
1123 while (f < ep->freqn - ep->freqn / 4) { 1123 while (f < ep->freqn - ep->freqn / 4) {
1124 f <<= 1; 1124 f <<= 1;
1125 shift++; 1125 shift++;
1126 } 1126 }
1127 while (f > ep->freqn + ep->freqn / 2) { 1127 while (f > ep->freqn + ep->freqn / 2) {
1128 f >>= 1; 1128 f >>= 1;
1129 shift--; 1129 shift--;
1130 } 1130 }
1131 ep->freqshift = shift; 1131 ep->freqshift = shift;
1132 } else if (ep->freqshift >= 0) 1132 } else if (ep->freqshift >= 0)
1133 f <<= ep->freqshift; 1133 f <<= ep->freqshift;
1134 else 1134 else
1135 f >>= -ep->freqshift; 1135 f >>= -ep->freqshift;
1136 1136
1137 if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) { 1137 if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1138 /* 1138 /*
1139 * If the frequency looks valid, set it. 1139 * If the frequency looks valid, set it.
1140 * This value is referred to in prepare_playback_urb(). 1140 * This value is referred to in prepare_playback_urb().
1141 */ 1141 */
1142 spin_lock_irqsave(&ep->lock, flags); 1142 spin_lock_irqsave(&ep->lock, flags);
1143 ep->freqm = f; 1143 ep->freqm = f;
1144 spin_unlock_irqrestore(&ep->lock, flags); 1144 spin_unlock_irqrestore(&ep->lock, flags);
1145 } else { 1145 } else {
1146 /* 1146 /*
1147 * Out of range; maybe the shift value is wrong. 1147 * Out of range; maybe the shift value is wrong.
1148 * Reset it so that we autodetect again the next time. 1148 * Reset it so that we autodetect again the next time.
1149 */ 1149 */
1150 ep->freqshift = INT_MIN; 1150 ep->freqshift = INT_MIN;
1151 } 1151 }
1152 } 1152 }
1153 1153
1154 1154