Commit | Line | Data |
---|---|---|
63978ab3 | 1 | /* |
e584bc3c | 2 | * Edirol UA-101/UA-1000 driver |
63978ab3 CL |
3 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> |
4 | * | |
5 | * This driver is free software: you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License, version 2. | |
7 | * | |
8 | * This driver is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * along with this driver. If not, see <http://www.gnu.org/licenses/>. | |
15 | */ | |
16 | ||
17 | #include <linux/init.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/slab.h> | |
20 | #include <linux/usb.h> | |
21 | #include <linux/usb/audio.h> | |
63978ab3 CL |
22 | #include <sound/core.h> |
23 | #include <sound/initval.h> | |
24 | #include <sound/pcm.h> | |
25 | #include <sound/pcm_params.h> | |
bc700ab1 | 26 | #include "../usbaudio.h" |
e5779998 | 27 | #include "../midi.h" |
63978ab3 | 28 | |
e584bc3c | 29 | MODULE_DESCRIPTION("Edirol UA-101/1000 driver"); |
63978ab3 CL |
30 | MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); |
31 | MODULE_LICENSE("GPL v2"); | |
e584bc3c | 32 | MODULE_SUPPORTED_DEVICE("{{Edirol,UA-101},{Edirol,UA-1000}}"); |
63978ab3 | 33 | |
63978ab3 CL |
34 | /* |
35 | * Should not be lower than the minimum scheduling delay of the host | |
36 | * controller. Some Intel controllers need more than one frame; as long as | |
37 | * that driver doesn't tell us about this, use 1.5 frames just to be sure. | |
38 | */ | |
39 | #define MIN_QUEUE_LENGTH 12 | |
40 | /* Somewhat random. */ | |
41 | #define MAX_QUEUE_LENGTH 30 | |
42 | /* | |
43 | * This magic value optimizes memory usage efficiency for the UA-101's packet | |
44 | * sizes at all sample rates, taking into account the stupid cache pool sizes | |
997ea58e | 45 | * that usb_alloc_coherent() uses. |
63978ab3 CL |
46 | */ |
47 | #define DEFAULT_QUEUE_LENGTH 21 | |
48 | ||
49 | #define MAX_PACKET_SIZE 672 /* hardware specific */ | |
50 | #define MAX_MEMORY_BUFFERS DIV_ROUND_UP(MAX_QUEUE_LENGTH, \ | |
51 | PAGE_SIZE / MAX_PACKET_SIZE) | |
52 | ||
53 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; | |
54 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; | |
55 | static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; | |
56 | static unsigned int queue_length = 21; | |
57 | ||
58 | module_param_array(index, int, NULL, 0444); | |
59 | MODULE_PARM_DESC(index, "card index"); | |
60 | module_param_array(id, charp, NULL, 0444); | |
61 | MODULE_PARM_DESC(id, "ID string"); | |
62 | module_param_array(enable, bool, NULL, 0444); | |
63 | MODULE_PARM_DESC(enable, "enable card"); | |
64 | module_param(queue_length, uint, 0644); | |
65 | MODULE_PARM_DESC(queue_length, "USB queue length in microframes, " | |
66 | __stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH)); | |
67 | ||
68 | enum { | |
69 | INTF_PLAYBACK, | |
70 | INTF_CAPTURE, | |
71 | INTF_MIDI, | |
72 | ||
73 | INTF_COUNT | |
74 | }; | |
75 | ||
76 | /* bits in struct ua101::states */ | |
77 | enum { | |
78 | USB_CAPTURE_RUNNING, | |
79 | USB_PLAYBACK_RUNNING, | |
80 | ALSA_CAPTURE_OPEN, | |
81 | ALSA_PLAYBACK_OPEN, | |
82 | ALSA_CAPTURE_RUNNING, | |
83 | ALSA_PLAYBACK_RUNNING, | |
84 | CAPTURE_URB_COMPLETED, | |
85 | PLAYBACK_URB_COMPLETED, | |
86 | DISCONNECTED, | |
87 | }; | |
88 | ||
89 | struct ua101 { | |
90 | struct usb_device *dev; | |
91 | struct snd_card *card; | |
92 | struct usb_interface *intf[INTF_COUNT]; | |
93 | int card_index; | |
94 | struct snd_pcm *pcm; | |
95 | struct list_head midi_list; | |
96 | u64 format_bit; | |
97 | unsigned int rate; | |
98 | unsigned int packets_per_second; | |
99 | spinlock_t lock; | |
100 | struct mutex mutex; | |
101 | unsigned long states; | |
102 | ||
103 | /* FIFO to synchronize playback rate to capture rate */ | |
104 | unsigned int rate_feedback_start; | |
105 | unsigned int rate_feedback_count; | |
106 | u8 rate_feedback[MAX_QUEUE_LENGTH]; | |
107 | ||
108 | struct list_head ready_playback_urbs; | |
109 | struct tasklet_struct playback_tasklet; | |
110 | wait_queue_head_t alsa_capture_wait; | |
111 | wait_queue_head_t rate_feedback_wait; | |
112 | wait_queue_head_t alsa_playback_wait; | |
113 | struct ua101_stream { | |
114 | struct snd_pcm_substream *substream; | |
115 | unsigned int usb_pipe; | |
116 | unsigned int channels; | |
117 | unsigned int frame_bytes; | |
118 | unsigned int max_packet_bytes; | |
119 | unsigned int period_pos; | |
120 | unsigned int buffer_pos; | |
121 | unsigned int queue_length; | |
122 | struct ua101_urb { | |
123 | struct urb urb; | |
124 | struct usb_iso_packet_descriptor iso_frame_desc[1]; | |
125 | struct list_head ready_list; | |
126 | } *urbs[MAX_QUEUE_LENGTH]; | |
127 | struct { | |
128 | unsigned int size; | |
129 | void *addr; | |
130 | dma_addr_t dma; | |
131 | } buffers[MAX_MEMORY_BUFFERS]; | |
132 | } capture, playback; | |
63978ab3 CL |
133 | }; |
134 | ||
135 | static DEFINE_MUTEX(devices_mutex); | |
136 | static unsigned int devices_used; | |
137 | static struct usb_driver ua101_driver; | |
138 | ||
139 | static void abort_alsa_playback(struct ua101 *ua); | |
140 | static void abort_alsa_capture(struct ua101 *ua); | |
141 | ||
63978ab3 CL |
142 | static const char *usb_error_string(int err) |
143 | { | |
144 | switch (err) { | |
145 | case -ENODEV: | |
146 | return "no device"; | |
147 | case -ENOENT: | |
148 | return "endpoint not enabled"; | |
149 | case -EPIPE: | |
150 | return "endpoint stalled"; | |
151 | case -ENOSPC: | |
152 | return "not enough bandwidth"; | |
153 | case -ESHUTDOWN: | |
154 | return "device disabled"; | |
155 | case -EHOSTUNREACH: | |
156 | return "device suspended"; | |
157 | case -EINVAL: | |
158 | case -EAGAIN: | |
159 | case -EFBIG: | |
160 | case -EMSGSIZE: | |
161 | return "internal error"; | |
162 | default: | |
163 | return "unknown error"; | |
164 | } | |
165 | } | |
166 | ||
167 | static void abort_usb_capture(struct ua101 *ua) | |
168 | { | |
169 | if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) { | |
170 | wake_up(&ua->alsa_capture_wait); | |
171 | wake_up(&ua->rate_feedback_wait); | |
172 | } | |
173 | } | |
174 | ||
175 | static void abort_usb_playback(struct ua101 *ua) | |
176 | { | |
177 | if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states)) | |
178 | wake_up(&ua->alsa_playback_wait); | |
179 | } | |
180 | ||
181 | static void playback_urb_complete(struct urb *usb_urb) | |
182 | { | |
183 | struct ua101_urb *urb = (struct ua101_urb *)usb_urb; | |
184 | struct ua101 *ua = urb->urb.context; | |
185 | unsigned long flags; | |
186 | ||
187 | if (unlikely(urb->urb.status == -ENOENT || /* unlinked */ | |
188 | urb->urb.status == -ENODEV || /* device removed */ | |
189 | urb->urb.status == -ECONNRESET || /* unlinked */ | |
190 | urb->urb.status == -ESHUTDOWN)) { /* device disabled */ | |
191 | abort_usb_playback(ua); | |
192 | abort_alsa_playback(ua); | |
193 | return; | |
194 | } | |
195 | ||
196 | if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) { | |
197 | /* append URB to FIFO */ | |
198 | spin_lock_irqsave(&ua->lock, flags); | |
199 | list_add_tail(&urb->ready_list, &ua->ready_playback_urbs); | |
200 | if (ua->rate_feedback_count > 0) | |
201 | tasklet_schedule(&ua->playback_tasklet); | |
202 | ua->playback.substream->runtime->delay -= | |
203 | urb->urb.iso_frame_desc[0].length / | |
204 | ua->playback.frame_bytes; | |
205 | spin_unlock_irqrestore(&ua->lock, flags); | |
206 | } | |
207 | } | |
208 | ||
209 | static void first_playback_urb_complete(struct urb *urb) | |
210 | { | |
211 | struct ua101 *ua = urb->context; | |
212 | ||
213 | urb->complete = playback_urb_complete; | |
214 | playback_urb_complete(urb); | |
215 | ||
216 | set_bit(PLAYBACK_URB_COMPLETED, &ua->states); | |
217 | wake_up(&ua->alsa_playback_wait); | |
218 | } | |
219 | ||
220 | /* copy data from the ALSA ring buffer into the URB buffer */ | |
221 | static bool copy_playback_data(struct ua101_stream *stream, struct urb *urb, | |
222 | unsigned int frames) | |
223 | { | |
224 | struct snd_pcm_runtime *runtime; | |
225 | unsigned int frame_bytes, frames1; | |
226 | const u8 *source; | |
227 | ||
228 | runtime = stream->substream->runtime; | |
229 | frame_bytes = stream->frame_bytes; | |
230 | source = runtime->dma_area + stream->buffer_pos * frame_bytes; | |
231 | if (stream->buffer_pos + frames <= runtime->buffer_size) { | |
232 | memcpy(urb->transfer_buffer, source, frames * frame_bytes); | |
233 | } else { | |
234 | /* wrap around at end of ring buffer */ | |
235 | frames1 = runtime->buffer_size - stream->buffer_pos; | |
236 | memcpy(urb->transfer_buffer, source, frames1 * frame_bytes); | |
237 | memcpy(urb->transfer_buffer + frames1 * frame_bytes, | |
238 | runtime->dma_area, (frames - frames1) * frame_bytes); | |
239 | } | |
240 | ||
241 | stream->buffer_pos += frames; | |
242 | if (stream->buffer_pos >= runtime->buffer_size) | |
243 | stream->buffer_pos -= runtime->buffer_size; | |
244 | stream->period_pos += frames; | |
245 | if (stream->period_pos >= runtime->period_size) { | |
246 | stream->period_pos -= runtime->period_size; | |
247 | return true; | |
248 | } | |
249 | return false; | |
250 | } | |
251 | ||
252 | static inline void add_with_wraparound(struct ua101 *ua, | |
253 | unsigned int *value, unsigned int add) | |
254 | { | |
255 | *value += add; | |
256 | if (*value >= ua->playback.queue_length) | |
257 | *value -= ua->playback.queue_length; | |
258 | } | |
259 | ||
260 | static void playback_tasklet(unsigned long data) | |
261 | { | |
262 | struct ua101 *ua = (void *)data; | |
263 | unsigned long flags; | |
264 | unsigned int frames; | |
265 | struct ua101_urb *urb; | |
266 | bool do_period_elapsed = false; | |
267 | int err; | |
268 | ||
269 | if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states))) | |
270 | return; | |
271 | ||
272 | /* | |
273 | * Synchronizing the playback rate to the capture rate is done by using | |
274 | * the same sequence of packet sizes for both streams. | |
275 | * Submitting a playback URB therefore requires both a ready URB and | |
276 | * the size of the corresponding capture packet, i.e., both playback | |
277 | * and capture URBs must have been completed. Since the USB core does | |
278 | * not guarantee that playback and capture complete callbacks are | |
279 | * called alternately, we use two FIFOs for packet sizes and read URBs; | |
280 | * submitting playback URBs is possible as long as both FIFOs are | |
281 | * nonempty. | |
282 | */ | |
283 | spin_lock_irqsave(&ua->lock, flags); | |
284 | while (ua->rate_feedback_count > 0 && | |
285 | !list_empty(&ua->ready_playback_urbs)) { | |
286 | /* take packet size out of FIFO */ | |
287 | frames = ua->rate_feedback[ua->rate_feedback_start]; | |
288 | add_with_wraparound(ua, &ua->rate_feedback_start, 1); | |
289 | ua->rate_feedback_count--; | |
290 | ||
291 | /* take URB out of FIFO */ | |
292 | urb = list_first_entry(&ua->ready_playback_urbs, | |
293 | struct ua101_urb, ready_list); | |
294 | list_del(&urb->ready_list); | |
295 | ||
296 | /* fill packet with data or silence */ | |
297 | urb->urb.iso_frame_desc[0].length = | |
298 | frames * ua->playback.frame_bytes; | |
299 | if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) | |
300 | do_period_elapsed |= copy_playback_data(&ua->playback, | |
301 | &urb->urb, | |
302 | frames); | |
303 | else | |
304 | memset(urb->urb.transfer_buffer, 0, | |
305 | urb->urb.iso_frame_desc[0].length); | |
306 | ||
307 | /* and off you go ... */ | |
308 | err = usb_submit_urb(&urb->urb, GFP_ATOMIC); | |
309 | if (unlikely(err < 0)) { | |
310 | spin_unlock_irqrestore(&ua->lock, flags); | |
311 | abort_usb_playback(ua); | |
312 | abort_alsa_playback(ua); | |
313 | dev_err(&ua->dev->dev, "USB request error %d: %s\n", | |
314 | err, usb_error_string(err)); | |
315 | return; | |
316 | } | |
317 | ua->playback.substream->runtime->delay += frames; | |
318 | } | |
319 | spin_unlock_irqrestore(&ua->lock, flags); | |
320 | if (do_period_elapsed) | |
321 | snd_pcm_period_elapsed(ua->playback.substream); | |
322 | } | |
323 | ||
324 | /* copy data from the URB buffer into the ALSA ring buffer */ | |
325 | static bool copy_capture_data(struct ua101_stream *stream, struct urb *urb, | |
326 | unsigned int frames) | |
327 | { | |
328 | struct snd_pcm_runtime *runtime; | |
329 | unsigned int frame_bytes, frames1; | |
330 | u8 *dest; | |
331 | ||
332 | runtime = stream->substream->runtime; | |
333 | frame_bytes = stream->frame_bytes; | |
334 | dest = runtime->dma_area + stream->buffer_pos * frame_bytes; | |
335 | if (stream->buffer_pos + frames <= runtime->buffer_size) { | |
336 | memcpy(dest, urb->transfer_buffer, frames * frame_bytes); | |
337 | } else { | |
338 | /* wrap around at end of ring buffer */ | |
339 | frames1 = runtime->buffer_size - stream->buffer_pos; | |
340 | memcpy(dest, urb->transfer_buffer, frames1 * frame_bytes); | |
341 | memcpy(runtime->dma_area, | |
342 | urb->transfer_buffer + frames1 * frame_bytes, | |
343 | (frames - frames1) * frame_bytes); | |
344 | } | |
345 | ||
346 | stream->buffer_pos += frames; | |
347 | if (stream->buffer_pos >= runtime->buffer_size) | |
348 | stream->buffer_pos -= runtime->buffer_size; | |
349 | stream->period_pos += frames; | |
350 | if (stream->period_pos >= runtime->period_size) { | |
351 | stream->period_pos -= runtime->period_size; | |
352 | return true; | |
353 | } | |
354 | return false; | |
355 | } | |
356 | ||
357 | static void capture_urb_complete(struct urb *urb) | |
358 | { | |
359 | struct ua101 *ua = urb->context; | |
360 | struct ua101_stream *stream = &ua->capture; | |
361 | unsigned long flags; | |
362 | unsigned int frames, write_ptr; | |
363 | bool do_period_elapsed; | |
364 | int err; | |
365 | ||
366 | if (unlikely(urb->status == -ENOENT || /* unlinked */ | |
367 | urb->status == -ENODEV || /* device removed */ | |
368 | urb->status == -ECONNRESET || /* unlinked */ | |
369 | urb->status == -ESHUTDOWN)) /* device disabled */ | |
370 | goto stream_stopped; | |
371 | ||
372 | if (urb->status >= 0 && urb->iso_frame_desc[0].status >= 0) | |
373 | frames = urb->iso_frame_desc[0].actual_length / | |
374 | stream->frame_bytes; | |
375 | else | |
376 | frames = 0; | |
377 | ||
378 | spin_lock_irqsave(&ua->lock, flags); | |
379 | ||
380 | if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) | |
381 | do_period_elapsed = copy_capture_data(stream, urb, frames); | |
382 | else | |
383 | do_period_elapsed = false; | |
384 | ||
385 | if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) { | |
386 | err = usb_submit_urb(urb, GFP_ATOMIC); | |
387 | if (unlikely(err < 0)) { | |
388 | spin_unlock_irqrestore(&ua->lock, flags); | |
389 | dev_err(&ua->dev->dev, "USB request error %d: %s\n", | |
390 | err, usb_error_string(err)); | |
391 | goto stream_stopped; | |
392 | } | |
393 | ||
394 | /* append packet size to FIFO */ | |
395 | write_ptr = ua->rate_feedback_start; | |
396 | add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count); | |
397 | ua->rate_feedback[write_ptr] = frames; | |
398 | if (ua->rate_feedback_count < ua->playback.queue_length) { | |
399 | ua->rate_feedback_count++; | |
400 | if (ua->rate_feedback_count == | |
401 | ua->playback.queue_length) | |
402 | wake_up(&ua->rate_feedback_wait); | |
403 | } else { | |
404 | /* | |
405 | * Ring buffer overflow; this happens when the playback | |
406 | * stream is not running. Throw away the oldest entry, | |
407 | * so that the playback stream, when it starts, sees | |
408 | * the most recent packet sizes. | |
409 | */ | |
410 | add_with_wraparound(ua, &ua->rate_feedback_start, 1); | |
411 | } | |
412 | if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) && | |
413 | !list_empty(&ua->ready_playback_urbs)) | |
414 | tasklet_schedule(&ua->playback_tasklet); | |
415 | } | |
416 | ||
417 | spin_unlock_irqrestore(&ua->lock, flags); | |
418 | ||
419 | if (do_period_elapsed) | |
420 | snd_pcm_period_elapsed(stream->substream); | |
421 | ||
63978ab3 CL |
422 | return; |
423 | ||
424 | stream_stopped: | |
425 | abort_usb_playback(ua); | |
426 | abort_usb_capture(ua); | |
427 | abort_alsa_playback(ua); | |
428 | abort_alsa_capture(ua); | |
429 | } | |
430 | ||
431 | static void first_capture_urb_complete(struct urb *urb) | |
432 | { | |
433 | struct ua101 *ua = urb->context; | |
434 | ||
435 | urb->complete = capture_urb_complete; | |
436 | capture_urb_complete(urb); | |
437 | ||
438 | set_bit(CAPTURE_URB_COMPLETED, &ua->states); | |
439 | wake_up(&ua->alsa_capture_wait); | |
440 | } | |
441 | ||
442 | static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream) | |
443 | { | |
444 | unsigned int i; | |
445 | ||
446 | for (i = 0; i < stream->queue_length; ++i) { | |
447 | int err = usb_submit_urb(&stream->urbs[i]->urb, GFP_KERNEL); | |
448 | if (err < 0) { | |
449 | dev_err(&ua->dev->dev, "USB request error %d: %s\n", | |
450 | err, usb_error_string(err)); | |
451 | return err; | |
452 | } | |
453 | } | |
454 | return 0; | |
455 | } | |
456 | ||
457 | static void kill_stream_urbs(struct ua101_stream *stream) | |
458 | { | |
459 | unsigned int i; | |
460 | ||
461 | for (i = 0; i < stream->queue_length; ++i) | |
462 | usb_kill_urb(&stream->urbs[i]->urb); | |
463 | } | |
464 | ||
465 | static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index) | |
466 | { | |
467 | struct usb_host_interface *alts; | |
468 | ||
469 | alts = ua->intf[intf_index]->cur_altsetting; | |
470 | if (alts->desc.bAlternateSetting != 1) { | |
471 | int err = usb_set_interface(ua->dev, | |
472 | alts->desc.bInterfaceNumber, 1); | |
473 | if (err < 0) { | |
474 | dev_err(&ua->dev->dev, | |
475 | "cannot initialize interface; error %d: %s\n", | |
476 | err, usb_error_string(err)); | |
477 | return err; | |
478 | } | |
479 | } | |
480 | return 0; | |
481 | } | |
482 | ||
483 | static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index) | |
484 | { | |
485 | struct usb_host_interface *alts; | |
486 | ||
487 | alts = ua->intf[intf_index]->cur_altsetting; | |
488 | if (alts->desc.bAlternateSetting != 0) { | |
489 | int err = usb_set_interface(ua->dev, | |
490 | alts->desc.bInterfaceNumber, 0); | |
491 | if (err < 0 && !test_bit(DISCONNECTED, &ua->states)) | |
492 | dev_warn(&ua->dev->dev, | |
493 | "interface reset failed; error %d: %s\n", | |
494 | err, usb_error_string(err)); | |
495 | } | |
496 | } | |
497 | ||
498 | static void stop_usb_capture(struct ua101 *ua) | |
499 | { | |
500 | clear_bit(USB_CAPTURE_RUNNING, &ua->states); | |
501 | ||
502 | kill_stream_urbs(&ua->capture); | |
503 | ||
504 | disable_iso_interface(ua, INTF_CAPTURE); | |
505 | } | |
506 | ||
507 | static int start_usb_capture(struct ua101 *ua) | |
508 | { | |
509 | int err; | |
510 | ||
511 | if (test_bit(DISCONNECTED, &ua->states)) | |
512 | return -ENODEV; | |
513 | ||
514 | if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) | |
515 | return 0; | |
516 | ||
517 | kill_stream_urbs(&ua->capture); | |
518 | ||
519 | err = enable_iso_interface(ua, INTF_CAPTURE); | |
520 | if (err < 0) | |
521 | return err; | |
522 | ||
523 | clear_bit(CAPTURE_URB_COMPLETED, &ua->states); | |
524 | ua->capture.urbs[0]->urb.complete = first_capture_urb_complete; | |
525 | ua->rate_feedback_start = 0; | |
526 | ua->rate_feedback_count = 0; | |
527 | ||
528 | set_bit(USB_CAPTURE_RUNNING, &ua->states); | |
529 | err = submit_stream_urbs(ua, &ua->capture); | |
530 | if (err < 0) | |
531 | stop_usb_capture(ua); | |
532 | return err; | |
533 | } | |
534 | ||
535 | static void stop_usb_playback(struct ua101 *ua) | |
536 | { | |
537 | clear_bit(USB_PLAYBACK_RUNNING, &ua->states); | |
538 | ||
539 | kill_stream_urbs(&ua->playback); | |
540 | ||
541 | tasklet_kill(&ua->playback_tasklet); | |
542 | ||
543 | disable_iso_interface(ua, INTF_PLAYBACK); | |
544 | } | |
545 | ||
546 | static int start_usb_playback(struct ua101 *ua) | |
547 | { | |
548 | unsigned int i, frames; | |
549 | struct urb *urb; | |
550 | int err = 0; | |
551 | ||
552 | if (test_bit(DISCONNECTED, &ua->states)) | |
553 | return -ENODEV; | |
554 | ||
555 | if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) | |
556 | return 0; | |
557 | ||
558 | kill_stream_urbs(&ua->playback); | |
559 | tasklet_kill(&ua->playback_tasklet); | |
560 | ||
561 | err = enable_iso_interface(ua, INTF_PLAYBACK); | |
562 | if (err < 0) | |
563 | return err; | |
564 | ||
565 | clear_bit(PLAYBACK_URB_COMPLETED, &ua->states); | |
566 | ua->playback.urbs[0]->urb.complete = | |
567 | first_playback_urb_complete; | |
568 | spin_lock_irq(&ua->lock); | |
569 | INIT_LIST_HEAD(&ua->ready_playback_urbs); | |
570 | spin_unlock_irq(&ua->lock); | |
571 | ||
572 | /* | |
573 | * We submit the initial URBs all at once, so we have to wait for the | |
574 | * packet size FIFO to be full. | |
575 | */ | |
576 | wait_event(ua->rate_feedback_wait, | |
577 | ua->rate_feedback_count >= ua->playback.queue_length || | |
578 | !test_bit(USB_CAPTURE_RUNNING, &ua->states) || | |
579 | test_bit(DISCONNECTED, &ua->states)); | |
580 | if (test_bit(DISCONNECTED, &ua->states)) { | |
581 | stop_usb_playback(ua); | |
582 | return -ENODEV; | |
583 | } | |
584 | if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) { | |
585 | stop_usb_playback(ua); | |
586 | return -EIO; | |
587 | } | |
588 | ||
589 | for (i = 0; i < ua->playback.queue_length; ++i) { | |
590 | /* all initial URBs contain silence */ | |
591 | spin_lock_irq(&ua->lock); | |
592 | frames = ua->rate_feedback[ua->rate_feedback_start]; | |
593 | add_with_wraparound(ua, &ua->rate_feedback_start, 1); | |
594 | ua->rate_feedback_count--; | |
595 | spin_unlock_irq(&ua->lock); | |
596 | urb = &ua->playback.urbs[i]->urb; | |
597 | urb->iso_frame_desc[0].length = | |
598 | frames * ua->playback.frame_bytes; | |
599 | memset(urb->transfer_buffer, 0, | |
600 | urb->iso_frame_desc[0].length); | |
601 | } | |
602 | ||
603 | set_bit(USB_PLAYBACK_RUNNING, &ua->states); | |
604 | err = submit_stream_urbs(ua, &ua->playback); | |
605 | if (err < 0) | |
606 | stop_usb_playback(ua); | |
607 | return err; | |
608 | } | |
609 | ||
610 | static void abort_alsa_capture(struct ua101 *ua) | |
611 | { | |
612 | if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) | |
613 | snd_pcm_stop(ua->capture.substream, SNDRV_PCM_STATE_XRUN); | |
614 | } | |
615 | ||
616 | static void abort_alsa_playback(struct ua101 *ua) | |
617 | { | |
618 | if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) | |
619 | snd_pcm_stop(ua->playback.substream, SNDRV_PCM_STATE_XRUN); | |
620 | } | |
621 | ||
622 | static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream, | |
623 | unsigned int channels) | |
624 | { | |
625 | int err; | |
626 | ||
627 | substream->runtime->hw.info = | |
628 | SNDRV_PCM_INFO_MMAP | | |
629 | SNDRV_PCM_INFO_MMAP_VALID | | |
630 | SNDRV_PCM_INFO_BATCH | | |
631 | SNDRV_PCM_INFO_INTERLEAVED | | |
632 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
633 | SNDRV_PCM_INFO_FIFO_IN_FRAMES; | |
634 | substream->runtime->hw.formats = ua->format_bit; | |
635 | substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate); | |
636 | substream->runtime->hw.rate_min = ua->rate; | |
637 | substream->runtime->hw.rate_max = ua->rate; | |
638 | substream->runtime->hw.channels_min = channels; | |
639 | substream->runtime->hw.channels_max = channels; | |
640 | substream->runtime->hw.buffer_bytes_max = 45000 * 1024; | |
641 | substream->runtime->hw.period_bytes_min = 1; | |
642 | substream->runtime->hw.period_bytes_max = UINT_MAX; | |
643 | substream->runtime->hw.periods_min = 2; | |
644 | substream->runtime->hw.periods_max = UINT_MAX; | |
645 | err = snd_pcm_hw_constraint_minmax(substream->runtime, | |
646 | SNDRV_PCM_HW_PARAM_PERIOD_TIME, | |
647 | 1500000 / ua->packets_per_second, | |
f4b1e98a | 648 | UINT_MAX); |
63978ab3 CL |
649 | if (err < 0) |
650 | return err; | |
651 | err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24); | |
652 | return err; | |
653 | } | |
654 | ||
655 | static int capture_pcm_open(struct snd_pcm_substream *substream) | |
656 | { | |
657 | struct ua101 *ua = substream->private_data; | |
658 | int err; | |
659 | ||
660 | ua->capture.substream = substream; | |
661 | err = set_stream_hw(ua, substream, ua->capture.channels); | |
662 | if (err < 0) | |
663 | return err; | |
664 | substream->runtime->hw.fifo_size = | |
665 | DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second); | |
666 | substream->runtime->delay = substream->runtime->hw.fifo_size; | |
667 | ||
668 | mutex_lock(&ua->mutex); | |
669 | err = start_usb_capture(ua); | |
670 | if (err >= 0) | |
671 | set_bit(ALSA_CAPTURE_OPEN, &ua->states); | |
672 | mutex_unlock(&ua->mutex); | |
673 | return err; | |
674 | } | |
675 | ||
676 | static int playback_pcm_open(struct snd_pcm_substream *substream) | |
677 | { | |
678 | struct ua101 *ua = substream->private_data; | |
679 | int err; | |
680 | ||
681 | ua->playback.substream = substream; | |
682 | err = set_stream_hw(ua, substream, ua->playback.channels); | |
683 | if (err < 0) | |
684 | return err; | |
685 | substream->runtime->hw.fifo_size = | |
686 | DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length, | |
687 | ua->packets_per_second); | |
688 | ||
689 | mutex_lock(&ua->mutex); | |
690 | err = start_usb_capture(ua); | |
691 | if (err < 0) | |
692 | goto error; | |
693 | err = start_usb_playback(ua); | |
694 | if (err < 0) { | |
695 | if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) | |
696 | stop_usb_capture(ua); | |
697 | goto error; | |
698 | } | |
699 | set_bit(ALSA_PLAYBACK_OPEN, &ua->states); | |
700 | error: | |
701 | mutex_unlock(&ua->mutex); | |
702 | return err; | |
703 | } | |
704 | ||
705 | static int capture_pcm_close(struct snd_pcm_substream *substream) | |
706 | { | |
707 | struct ua101 *ua = substream->private_data; | |
708 | ||
709 | mutex_lock(&ua->mutex); | |
710 | clear_bit(ALSA_CAPTURE_OPEN, &ua->states); | |
711 | if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states)) | |
712 | stop_usb_capture(ua); | |
713 | mutex_unlock(&ua->mutex); | |
714 | return 0; | |
715 | } | |
716 | ||
717 | static int playback_pcm_close(struct snd_pcm_substream *substream) | |
718 | { | |
719 | struct ua101 *ua = substream->private_data; | |
720 | ||
721 | mutex_lock(&ua->mutex); | |
722 | stop_usb_playback(ua); | |
723 | clear_bit(ALSA_PLAYBACK_OPEN, &ua->states); | |
724 | if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) | |
725 | stop_usb_capture(ua); | |
726 | mutex_unlock(&ua->mutex); | |
727 | return 0; | |
728 | } | |
729 | ||
730 | static int capture_pcm_hw_params(struct snd_pcm_substream *substream, | |
731 | struct snd_pcm_hw_params *hw_params) | |
732 | { | |
733 | struct ua101 *ua = substream->private_data; | |
734 | int err; | |
735 | ||
736 | mutex_lock(&ua->mutex); | |
737 | err = start_usb_capture(ua); | |
738 | mutex_unlock(&ua->mutex); | |
739 | if (err < 0) | |
740 | return err; | |
741 | ||
5b4b2a41 CL |
742 | return snd_pcm_lib_alloc_vmalloc_buffer(substream, |
743 | params_buffer_bytes(hw_params)); | |
63978ab3 CL |
744 | } |
745 | ||
746 | static int playback_pcm_hw_params(struct snd_pcm_substream *substream, | |
747 | struct snd_pcm_hw_params *hw_params) | |
748 | { | |
749 | struct ua101 *ua = substream->private_data; | |
750 | int err; | |
751 | ||
752 | mutex_lock(&ua->mutex); | |
753 | err = start_usb_capture(ua); | |
754 | if (err >= 0) | |
755 | err = start_usb_playback(ua); | |
756 | mutex_unlock(&ua->mutex); | |
757 | if (err < 0) | |
758 | return err; | |
759 | ||
5b4b2a41 CL |
760 | return snd_pcm_lib_alloc_vmalloc_buffer(substream, |
761 | params_buffer_bytes(hw_params)); | |
63978ab3 CL |
762 | } |
763 | ||
764 | static int ua101_pcm_hw_free(struct snd_pcm_substream *substream) | |
765 | { | |
5b4b2a41 | 766 | return snd_pcm_lib_free_vmalloc_buffer(substream); |
63978ab3 CL |
767 | } |
768 | ||
769 | static int capture_pcm_prepare(struct snd_pcm_substream *substream) | |
770 | { | |
771 | struct ua101 *ua = substream->private_data; | |
772 | int err; | |
773 | ||
774 | mutex_lock(&ua->mutex); | |
775 | err = start_usb_capture(ua); | |
776 | mutex_unlock(&ua->mutex); | |
777 | if (err < 0) | |
778 | return err; | |
779 | ||
780 | /* | |
781 | * The EHCI driver schedules the first packet of an iso stream at 10 ms | |
782 | * in the future, i.e., no data is actually captured for that long. | |
783 | * Take the wait here so that the stream is known to be actually | |
784 | * running when the start trigger has been called. | |
785 | */ | |
786 | wait_event(ua->alsa_capture_wait, | |
787 | test_bit(CAPTURE_URB_COMPLETED, &ua->states) || | |
788 | !test_bit(USB_CAPTURE_RUNNING, &ua->states)); | |
789 | if (test_bit(DISCONNECTED, &ua->states)) | |
790 | return -ENODEV; | |
791 | if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) | |
792 | return -EIO; | |
793 | ||
794 | ua->capture.period_pos = 0; | |
795 | ua->capture.buffer_pos = 0; | |
796 | return 0; | |
797 | } | |
798 | ||
799 | static int playback_pcm_prepare(struct snd_pcm_substream *substream) | |
800 | { | |
801 | struct ua101 *ua = substream->private_data; | |
802 | int err; | |
803 | ||
804 | mutex_lock(&ua->mutex); | |
805 | err = start_usb_capture(ua); | |
806 | if (err >= 0) | |
807 | err = start_usb_playback(ua); | |
808 | mutex_unlock(&ua->mutex); | |
809 | if (err < 0) | |
810 | return err; | |
811 | ||
812 | /* see the comment in capture_pcm_prepare() */ | |
813 | wait_event(ua->alsa_playback_wait, | |
814 | test_bit(PLAYBACK_URB_COMPLETED, &ua->states) || | |
815 | !test_bit(USB_PLAYBACK_RUNNING, &ua->states)); | |
816 | if (test_bit(DISCONNECTED, &ua->states)) | |
817 | return -ENODEV; | |
818 | if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) | |
819 | return -EIO; | |
820 | ||
821 | substream->runtime->delay = 0; | |
822 | ua->playback.period_pos = 0; | |
823 | ua->playback.buffer_pos = 0; | |
824 | return 0; | |
825 | } | |
826 | ||
827 | static int capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd) | |
828 | { | |
829 | struct ua101 *ua = substream->private_data; | |
830 | ||
831 | switch (cmd) { | |
832 | case SNDRV_PCM_TRIGGER_START: | |
833 | if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) | |
834 | return -EIO; | |
835 | set_bit(ALSA_CAPTURE_RUNNING, &ua->states); | |
836 | return 0; | |
837 | case SNDRV_PCM_TRIGGER_STOP: | |
838 | clear_bit(ALSA_CAPTURE_RUNNING, &ua->states); | |
839 | return 0; | |
840 | default: | |
841 | return -EINVAL; | |
842 | } | |
843 | } | |
844 | ||
845 | static int playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd) | |
846 | { | |
847 | struct ua101 *ua = substream->private_data; | |
848 | ||
849 | switch (cmd) { | |
850 | case SNDRV_PCM_TRIGGER_START: | |
851 | if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) | |
852 | return -EIO; | |
853 | set_bit(ALSA_PLAYBACK_RUNNING, &ua->states); | |
854 | return 0; | |
855 | case SNDRV_PCM_TRIGGER_STOP: | |
856 | clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states); | |
857 | return 0; | |
858 | default: | |
859 | return -EINVAL; | |
860 | } | |
861 | } | |
862 | ||
863 | static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua, | |
864 | struct ua101_stream *stream) | |
865 | { | |
866 | unsigned long flags; | |
867 | unsigned int pos; | |
868 | ||
869 | spin_lock_irqsave(&ua->lock, flags); | |
870 | pos = stream->buffer_pos; | |
871 | spin_unlock_irqrestore(&ua->lock, flags); | |
872 | return pos; | |
873 | } | |
874 | ||
875 | static snd_pcm_uframes_t capture_pcm_pointer(struct snd_pcm_substream *subs) | |
876 | { | |
877 | struct ua101 *ua = subs->private_data; | |
878 | ||
879 | return ua101_pcm_pointer(ua, &ua->capture); | |
880 | } | |
881 | ||
882 | static snd_pcm_uframes_t playback_pcm_pointer(struct snd_pcm_substream *subs) | |
883 | { | |
884 | struct ua101 *ua = subs->private_data; | |
885 | ||
886 | return ua101_pcm_pointer(ua, &ua->playback); | |
887 | } | |
888 | ||
889 | static struct snd_pcm_ops capture_pcm_ops = { | |
890 | .open = capture_pcm_open, | |
891 | .close = capture_pcm_close, | |
892 | .ioctl = snd_pcm_lib_ioctl, | |
893 | .hw_params = capture_pcm_hw_params, | |
894 | .hw_free = ua101_pcm_hw_free, | |
895 | .prepare = capture_pcm_prepare, | |
896 | .trigger = capture_pcm_trigger, | |
897 | .pointer = capture_pcm_pointer, | |
5b4b2a41 | 898 | .page = snd_pcm_lib_get_vmalloc_page, |
c32d977b | 899 | .mmap = snd_pcm_lib_mmap_vmalloc, |
63978ab3 CL |
900 | }; |
901 | ||
902 | static struct snd_pcm_ops playback_pcm_ops = { | |
903 | .open = playback_pcm_open, | |
904 | .close = playback_pcm_close, | |
905 | .ioctl = snd_pcm_lib_ioctl, | |
906 | .hw_params = playback_pcm_hw_params, | |
907 | .hw_free = ua101_pcm_hw_free, | |
908 | .prepare = playback_pcm_prepare, | |
909 | .trigger = playback_pcm_trigger, | |
910 | .pointer = playback_pcm_pointer, | |
5b4b2a41 | 911 | .page = snd_pcm_lib_get_vmalloc_page, |
c32d977b | 912 | .mmap = snd_pcm_lib_mmap_vmalloc, |
63978ab3 CL |
913 | }; |
914 | ||
915 | static const struct uac_format_type_i_discrete_descriptor * | |
916 | find_format_descriptor(struct usb_interface *interface) | |
917 | { | |
918 | struct usb_host_interface *alt; | |
919 | u8 *extra; | |
920 | int extralen; | |
921 | ||
922 | if (interface->num_altsetting != 2) { | |
923 | dev_err(&interface->dev, "invalid num_altsetting\n"); | |
924 | return NULL; | |
925 | } | |
926 | ||
927 | alt = &interface->altsetting[0]; | |
928 | if (alt->desc.bNumEndpoints != 0) { | |
929 | dev_err(&interface->dev, "invalid bNumEndpoints\n"); | |
930 | return NULL; | |
931 | } | |
932 | ||
933 | alt = &interface->altsetting[1]; | |
934 | if (alt->desc.bNumEndpoints != 1) { | |
935 | dev_err(&interface->dev, "invalid bNumEndpoints\n"); | |
936 | return NULL; | |
937 | } | |
938 | ||
939 | extra = alt->extra; | |
940 | extralen = alt->extralen; | |
941 | while (extralen >= sizeof(struct usb_descriptor_header)) { | |
942 | struct uac_format_type_i_discrete_descriptor *desc; | |
943 | ||
944 | desc = (struct uac_format_type_i_discrete_descriptor *)extra; | |
945 | if (desc->bLength > extralen) { | |
946 | dev_err(&interface->dev, "descriptor overflow\n"); | |
947 | return NULL; | |
948 | } | |
949 | if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) && | |
950 | desc->bDescriptorType == USB_DT_CS_INTERFACE && | |
951 | desc->bDescriptorSubtype == UAC_FORMAT_TYPE) { | |
952 | if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM || | |
953 | desc->bSamFreqType != 1) { | |
954 | dev_err(&interface->dev, | |
955 | "invalid format type\n"); | |
956 | return NULL; | |
957 | } | |
958 | return desc; | |
959 | } | |
960 | extralen -= desc->bLength; | |
961 | extra += desc->bLength; | |
962 | } | |
963 | dev_err(&interface->dev, "sample format descriptor not found\n"); | |
964 | return NULL; | |
965 | } | |
966 | ||
967 | static int detect_usb_format(struct ua101 *ua) | |
968 | { | |
969 | const struct uac_format_type_i_discrete_descriptor *fmt_capture; | |
970 | const struct uac_format_type_i_discrete_descriptor *fmt_playback; | |
971 | const struct usb_endpoint_descriptor *epd; | |
972 | unsigned int rate2; | |
973 | ||
974 | fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]); | |
975 | fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]); | |
976 | if (!fmt_capture || !fmt_playback) | |
977 | return -ENXIO; | |
978 | ||
979 | switch (fmt_capture->bSubframeSize) { | |
980 | case 3: | |
981 | ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE; | |
982 | break; | |
983 | case 4: | |
984 | ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE; | |
985 | break; | |
986 | default: | |
987 | dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n"); | |
988 | return -ENXIO; | |
989 | } | |
990 | if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) { | |
991 | dev_err(&ua->dev->dev, | |
992 | "playback/capture sample widths do not match\n"); | |
993 | return -ENXIO; | |
994 | } | |
995 | ||
996 | if (fmt_capture->bBitResolution != 24 || | |
997 | fmt_playback->bBitResolution != 24) { | |
998 | dev_err(&ua->dev->dev, "sample width is not 24 bits\n"); | |
999 | return -ENXIO; | |
1000 | } | |
1001 | ||
1002 | ua->rate = combine_triple(fmt_capture->tSamFreq[0]); | |
1003 | rate2 = combine_triple(fmt_playback->tSamFreq[0]); | |
1004 | if (ua->rate != rate2) { | |
1005 | dev_err(&ua->dev->dev, | |
1006 | "playback/capture rates do not match: %u/%u\n", | |
1007 | rate2, ua->rate); | |
1008 | return -ENXIO; | |
1009 | } | |
1010 | ||
1011 | switch (ua->dev->speed) { | |
1012 | case USB_SPEED_FULL: | |
1013 | ua->packets_per_second = 1000; | |
1014 | break; | |
1015 | case USB_SPEED_HIGH: | |
1016 | ua->packets_per_second = 8000; | |
1017 | break; | |
1018 | default: | |
1019 | dev_err(&ua->dev->dev, "unknown device speed\n"); | |
1020 | return -ENXIO; | |
1021 | } | |
1022 | ||
1023 | ua->capture.channels = fmt_capture->bNrChannels; | |
1024 | ua->playback.channels = fmt_playback->bNrChannels; | |
1025 | ua->capture.frame_bytes = | |
1026 | fmt_capture->bSubframeSize * ua->capture.channels; | |
1027 | ua->playback.frame_bytes = | |
1028 | fmt_playback->bSubframeSize * ua->playback.channels; | |
1029 | ||
1030 | epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc; | |
1031 | if (!usb_endpoint_is_isoc_in(epd)) { | |
1032 | dev_err(&ua->dev->dev, "invalid capture endpoint\n"); | |
1033 | return -ENXIO; | |
1034 | } | |
1035 | ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd)); | |
1036 | ua->capture.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize); | |
1037 | ||
1038 | epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc; | |
1039 | if (!usb_endpoint_is_isoc_out(epd)) { | |
1040 | dev_err(&ua->dev->dev, "invalid playback endpoint\n"); | |
1041 | return -ENXIO; | |
1042 | } | |
1043 | ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd)); | |
1044 | ua->playback.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize); | |
1045 | return 0; | |
1046 | } | |
1047 | ||
1048 | static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) | |
1049 | { | |
1050 | unsigned int remaining_packets, packets, packets_per_page, i; | |
1051 | size_t size; | |
1052 | ||
1053 | stream->queue_length = queue_length; | |
1054 | stream->queue_length = max(stream->queue_length, | |
1055 | (unsigned int)MIN_QUEUE_LENGTH); | |
1056 | stream->queue_length = min(stream->queue_length, | |
1057 | (unsigned int)MAX_QUEUE_LENGTH); | |
1058 | ||
1059 | /* | |
997ea58e | 1060 | * The cache pool sizes used by usb_alloc_coherent() (128, 512, 2048) are |
63978ab3 CL |
1061 | * quite bad when used with the packet sizes of this device (e.g. 280, |
1062 | * 520, 624). Therefore, we allocate and subdivide entire pages, using | |
1063 | * a smaller buffer only for the last chunk. | |
1064 | */ | |
1065 | remaining_packets = stream->queue_length; | |
1066 | packets_per_page = PAGE_SIZE / stream->max_packet_bytes; | |
1067 | for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) { | |
1068 | packets = min(remaining_packets, packets_per_page); | |
1069 | size = packets * stream->max_packet_bytes; | |
1070 | stream->buffers[i].addr = | |
997ea58e DM |
1071 | usb_alloc_coherent(ua->dev, size, GFP_KERNEL, |
1072 | &stream->buffers[i].dma); | |
63978ab3 CL |
1073 | if (!stream->buffers[i].addr) |
1074 | return -ENOMEM; | |
1075 | stream->buffers[i].size = size; | |
1076 | remaining_packets -= packets; | |
1077 | if (!remaining_packets) | |
1078 | break; | |
1079 | } | |
1080 | if (remaining_packets) { | |
1081 | dev_err(&ua->dev->dev, "too many packets\n"); | |
1082 | return -ENXIO; | |
1083 | } | |
1084 | return 0; | |
1085 | } | |
1086 | ||
1087 | static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) | |
1088 | { | |
1089 | unsigned int i; | |
1090 | ||
1091 | for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) | |
997ea58e DM |
1092 | usb_free_coherent(ua->dev, |
1093 | stream->buffers[i].size, | |
1094 | stream->buffers[i].addr, | |
1095 | stream->buffers[i].dma); | |
63978ab3 CL |
1096 | } |
1097 | ||
1098 | static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream, | |
1099 | void (*urb_complete)(struct urb *)) | |
1100 | { | |
1101 | unsigned max_packet_size = stream->max_packet_bytes; | |
1102 | struct ua101_urb *urb; | |
1103 | unsigned int b, u = 0; | |
1104 | ||
1105 | for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) { | |
1106 | unsigned int size = stream->buffers[b].size; | |
1107 | u8 *addr = stream->buffers[b].addr; | |
1108 | dma_addr_t dma = stream->buffers[b].dma; | |
1109 | ||
1110 | while (size >= max_packet_size) { | |
1111 | if (u >= stream->queue_length) | |
1112 | goto bufsize_error; | |
1113 | urb = kmalloc(sizeof(*urb), GFP_KERNEL); | |
1114 | if (!urb) | |
1115 | return -ENOMEM; | |
1116 | usb_init_urb(&urb->urb); | |
1117 | urb->urb.dev = ua->dev; | |
1118 | urb->urb.pipe = stream->usb_pipe; | |
1119 | urb->urb.transfer_flags = URB_ISO_ASAP | | |
1120 | URB_NO_TRANSFER_DMA_MAP; | |
1121 | urb->urb.transfer_buffer = addr; | |
1122 | urb->urb.transfer_dma = dma; | |
1123 | urb->urb.transfer_buffer_length = max_packet_size; | |
1124 | urb->urb.number_of_packets = 1; | |
1125 | urb->urb.interval = 1; | |
1126 | urb->urb.context = ua; | |
1127 | urb->urb.complete = urb_complete; | |
1128 | urb->urb.iso_frame_desc[0].offset = 0; | |
1129 | urb->urb.iso_frame_desc[0].length = max_packet_size; | |
1130 | stream->urbs[u++] = urb; | |
1131 | size -= max_packet_size; | |
1132 | addr += max_packet_size; | |
1133 | dma += max_packet_size; | |
1134 | } | |
1135 | } | |
1136 | if (u == stream->queue_length) | |
1137 | return 0; | |
1138 | bufsize_error: | |
1139 | dev_err(&ua->dev->dev, "internal buffer size error\n"); | |
1140 | return -ENXIO; | |
1141 | } | |
1142 | ||
1143 | static void free_stream_urbs(struct ua101_stream *stream) | |
1144 | { | |
1145 | unsigned int i; | |
1146 | ||
1147 | for (i = 0; i < stream->queue_length; ++i) | |
1148 | kfree(stream->urbs[i]); | |
1149 | } | |
1150 | ||
1151 | static void free_usb_related_resources(struct ua101 *ua, | |
1152 | struct usb_interface *interface) | |
1153 | { | |
1154 | unsigned int i; | |
1155 | ||
1156 | free_stream_urbs(&ua->capture); | |
1157 | free_stream_urbs(&ua->playback); | |
1158 | free_stream_buffers(ua, &ua->capture); | |
1159 | free_stream_buffers(ua, &ua->playback); | |
1160 | ||
1161 | for (i = 0; i < ARRAY_SIZE(ua->intf); ++i) | |
1162 | if (ua->intf[i]) { | |
1163 | usb_set_intfdata(ua->intf[i], NULL); | |
1164 | if (ua->intf[i] != interface) | |
1165 | usb_driver_release_interface(&ua101_driver, | |
1166 | ua->intf[i]); | |
1167 | } | |
1168 | } | |
1169 | ||
1170 | static void ua101_card_free(struct snd_card *card) | |
1171 | { | |
1172 | struct ua101 *ua = card->private_data; | |
1173 | ||
1174 | mutex_destroy(&ua->mutex); | |
1175 | } | |
1176 | ||
1177 | static int ua101_probe(struct usb_interface *interface, | |
1178 | const struct usb_device_id *usb_id) | |
1179 | { | |
1180 | static const struct snd_usb_midi_endpoint_info midi_ep = { | |
1181 | .out_cables = 0x0001, | |
1182 | .in_cables = 0x0001 | |
1183 | }; | |
1184 | static const struct snd_usb_audio_quirk midi_quirk = { | |
1185 | .type = QUIRK_MIDI_FIXED_ENDPOINT, | |
1186 | .data = &midi_ep | |
1187 | }; | |
e584bc3c CL |
1188 | static const int intf_numbers[2][3] = { |
1189 | { /* UA-101 */ | |
1190 | [INTF_PLAYBACK] = 0, | |
1191 | [INTF_CAPTURE] = 1, | |
1192 | [INTF_MIDI] = 2, | |
1193 | }, | |
1194 | { /* UA-1000 */ | |
1195 | [INTF_CAPTURE] = 1, | |
1196 | [INTF_PLAYBACK] = 2, | |
1197 | [INTF_MIDI] = 3, | |
1198 | }, | |
1199 | }; | |
63978ab3 CL |
1200 | struct snd_card *card; |
1201 | struct ua101 *ua; | |
1202 | unsigned int card_index, i; | |
e584bc3c CL |
1203 | int is_ua1000; |
1204 | const char *name; | |
63978ab3 CL |
1205 | char usb_path[32]; |
1206 | int err; | |
1207 | ||
e584bc3c CL |
1208 | is_ua1000 = usb_id->idProduct == 0x0044; |
1209 | ||
1210 | if (interface->altsetting->desc.bInterfaceNumber != | |
1211 | intf_numbers[is_ua1000][0]) | |
63978ab3 CL |
1212 | return -ENODEV; |
1213 | ||
1214 | mutex_lock(&devices_mutex); | |
1215 | ||
1216 | for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) | |
1217 | if (enable[card_index] && !(devices_used & (1 << card_index))) | |
1218 | break; | |
1219 | if (card_index >= SNDRV_CARDS) { | |
1220 | mutex_unlock(&devices_mutex); | |
1221 | return -ENOENT; | |
1222 | } | |
1223 | err = snd_card_create(index[card_index], id[card_index], THIS_MODULE, | |
1224 | sizeof(*ua), &card); | |
1225 | if (err < 0) { | |
1226 | mutex_unlock(&devices_mutex); | |
1227 | return err; | |
1228 | } | |
1229 | card->private_free = ua101_card_free; | |
1230 | ua = card->private_data; | |
1231 | ua->dev = interface_to_usbdev(interface); | |
1232 | ua->card = card; | |
1233 | ua->card_index = card_index; | |
1234 | INIT_LIST_HEAD(&ua->midi_list); | |
1235 | spin_lock_init(&ua->lock); | |
1236 | mutex_init(&ua->mutex); | |
1237 | INIT_LIST_HEAD(&ua->ready_playback_urbs); | |
1238 | tasklet_init(&ua->playback_tasklet, | |
1239 | playback_tasklet, (unsigned long)ua); | |
1240 | init_waitqueue_head(&ua->alsa_capture_wait); | |
1241 | init_waitqueue_head(&ua->rate_feedback_wait); | |
1242 | init_waitqueue_head(&ua->alsa_playback_wait); | |
1243 | ||
63978ab3 CL |
1244 | ua->intf[0] = interface; |
1245 | for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) { | |
e584bc3c CL |
1246 | ua->intf[i] = usb_ifnum_to_if(ua->dev, |
1247 | intf_numbers[is_ua1000][i]); | |
63978ab3 | 1248 | if (!ua->intf[i]) { |
e584bc3c CL |
1249 | dev_err(&ua->dev->dev, "interface %u not found\n", |
1250 | intf_numbers[is_ua1000][i]); | |
63978ab3 CL |
1251 | err = -ENXIO; |
1252 | goto probe_error; | |
1253 | } | |
1254 | err = usb_driver_claim_interface(&ua101_driver, | |
1255 | ua->intf[i], ua); | |
1256 | if (err < 0) { | |
1257 | ua->intf[i] = NULL; | |
1258 | err = -EBUSY; | |
1259 | goto probe_error; | |
1260 | } | |
1261 | } | |
63978ab3 CL |
1262 | |
1263 | snd_card_set_dev(card, &interface->dev); | |
1264 | ||
63978ab3 CL |
1265 | err = detect_usb_format(ua); |
1266 | if (err < 0) | |
1267 | goto probe_error; | |
63978ab3 | 1268 | |
e584bc3c | 1269 | name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101"; |
63978ab3 | 1270 | strcpy(card->driver, "UA-101"); |
e584bc3c | 1271 | strcpy(card->shortname, name); |
63978ab3 CL |
1272 | usb_make_path(ua->dev, usb_path, sizeof(usb_path)); |
1273 | snprintf(ua->card->longname, sizeof(ua->card->longname), | |
e584bc3c | 1274 | "EDIROL %s (serial %s), %u Hz at %s, %s speed", name, |
63978ab3 CL |
1275 | ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path, |
1276 | ua->dev->speed == USB_SPEED_HIGH ? "high" : "full"); | |
1277 | ||
1278 | err = alloc_stream_buffers(ua, &ua->capture); | |
1279 | if (err < 0) | |
1280 | goto probe_error; | |
1281 | err = alloc_stream_buffers(ua, &ua->playback); | |
1282 | if (err < 0) | |
1283 | goto probe_error; | |
1284 | ||
1285 | err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete); | |
1286 | if (err < 0) | |
1287 | goto probe_error; | |
1288 | err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete); | |
1289 | if (err < 0) | |
1290 | goto probe_error; | |
1291 | ||
e584bc3c | 1292 | err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm); |
63978ab3 CL |
1293 | if (err < 0) |
1294 | goto probe_error; | |
1295 | ua->pcm->private_data = ua; | |
e584bc3c | 1296 | strcpy(ua->pcm->name, name); |
63978ab3 CL |
1297 | snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops); |
1298 | snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops); | |
1299 | ||
63978ab3 CL |
1300 | err = snd_usbmidi_create(card, ua->intf[INTF_MIDI], |
1301 | &ua->midi_list, &midi_quirk); | |
1302 | if (err < 0) | |
1303 | goto probe_error; | |
63978ab3 CL |
1304 | |
1305 | err = snd_card_register(card); | |
1306 | if (err < 0) | |
1307 | goto probe_error; | |
1308 | ||
1309 | usb_set_intfdata(interface, ua); | |
1310 | devices_used |= 1 << card_index; | |
1311 | ||
1312 | mutex_unlock(&devices_mutex); | |
1313 | return 0; | |
1314 | ||
1315 | probe_error: | |
1316 | free_usb_related_resources(ua, interface); | |
1317 | snd_card_free(card); | |
1318 | mutex_unlock(&devices_mutex); | |
1319 | return err; | |
1320 | } | |
1321 | ||
1322 | static void ua101_disconnect(struct usb_interface *interface) | |
1323 | { | |
1324 | struct ua101 *ua = usb_get_intfdata(interface); | |
1325 | struct list_head *midi; | |
1326 | ||
1327 | if (!ua) | |
1328 | return; | |
1329 | ||
1330 | mutex_lock(&devices_mutex); | |
1331 | ||
1332 | set_bit(DISCONNECTED, &ua->states); | |
1333 | wake_up(&ua->rate_feedback_wait); | |
1334 | ||
1335 | /* make sure that userspace cannot create new requests */ | |
1336 | snd_card_disconnect(ua->card); | |
1337 | ||
1338 | /* make sure that there are no pending USB requests */ | |
1339 | __list_for_each(midi, &ua->midi_list) | |
1340 | snd_usbmidi_disconnect(midi); | |
1341 | abort_alsa_playback(ua); | |
1342 | abort_alsa_capture(ua); | |
1343 | mutex_lock(&ua->mutex); | |
1344 | stop_usb_playback(ua); | |
1345 | stop_usb_capture(ua); | |
1346 | mutex_unlock(&ua->mutex); | |
1347 | ||
1348 | free_usb_related_resources(ua, interface); | |
1349 | ||
1350 | devices_used &= ~(1 << ua->card_index); | |
1351 | ||
1352 | snd_card_free_when_closed(ua->card); | |
1353 | ||
1354 | mutex_unlock(&devices_mutex); | |
1355 | } | |
1356 | ||
1357 | static struct usb_device_id ua101_ids[] = { | |
e584bc3c CL |
1358 | { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */ |
1359 | { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */ | |
1360 | { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */ | |
63978ab3 CL |
1361 | { } |
1362 | }; | |
1363 | MODULE_DEVICE_TABLE(usb, ua101_ids); | |
1364 | ||
1365 | static struct usb_driver ua101_driver = { | |
1366 | .name = "snd-ua101", | |
1367 | .id_table = ua101_ids, | |
1368 | .probe = ua101_probe, | |
1369 | .disconnect = ua101_disconnect, | |
1370 | #if 0 | |
1371 | .suspend = ua101_suspend, | |
1372 | .resume = ua101_resume, | |
1373 | #endif | |
1374 | }; | |
1375 | ||
1376 | static int __init alsa_card_ua101_init(void) | |
1377 | { | |
1378 | return usb_register(&ua101_driver); | |
1379 | } | |
1380 | ||
1381 | static void __exit alsa_card_ua101_exit(void) | |
1382 | { | |
1383 | usb_deregister(&ua101_driver); | |
1384 | mutex_destroy(&devices_mutex); | |
1385 | } | |
1386 | ||
1387 | module_init(alsa_card_ua101_init); | |
1388 | module_exit(alsa_card_ua101_exit); |