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) | |
862a6244 CL |
462 | if (stream->urbs[i]) |
463 | usb_kill_urb(&stream->urbs[i]->urb); | |
63978ab3 CL |
464 | } |
465 | ||
466 | static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index) | |
467 | { | |
468 | struct usb_host_interface *alts; | |
469 | ||
470 | alts = ua->intf[intf_index]->cur_altsetting; | |
471 | if (alts->desc.bAlternateSetting != 1) { | |
472 | int err = usb_set_interface(ua->dev, | |
473 | alts->desc.bInterfaceNumber, 1); | |
474 | if (err < 0) { | |
475 | dev_err(&ua->dev->dev, | |
476 | "cannot initialize interface; error %d: %s\n", | |
477 | err, usb_error_string(err)); | |
478 | return err; | |
479 | } | |
480 | } | |
481 | return 0; | |
482 | } | |
483 | ||
484 | static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index) | |
485 | { | |
486 | struct usb_host_interface *alts; | |
487 | ||
862a6244 CL |
488 | if (!ua->intf[intf_index]) |
489 | return; | |
490 | ||
63978ab3 CL |
491 | alts = ua->intf[intf_index]->cur_altsetting; |
492 | if (alts->desc.bAlternateSetting != 0) { | |
493 | int err = usb_set_interface(ua->dev, | |
494 | alts->desc.bInterfaceNumber, 0); | |
495 | if (err < 0 && !test_bit(DISCONNECTED, &ua->states)) | |
496 | dev_warn(&ua->dev->dev, | |
497 | "interface reset failed; error %d: %s\n", | |
498 | err, usb_error_string(err)); | |
499 | } | |
500 | } | |
501 | ||
502 | static void stop_usb_capture(struct ua101 *ua) | |
503 | { | |
504 | clear_bit(USB_CAPTURE_RUNNING, &ua->states); | |
505 | ||
506 | kill_stream_urbs(&ua->capture); | |
507 | ||
508 | disable_iso_interface(ua, INTF_CAPTURE); | |
509 | } | |
510 | ||
511 | static int start_usb_capture(struct ua101 *ua) | |
512 | { | |
513 | int err; | |
514 | ||
515 | if (test_bit(DISCONNECTED, &ua->states)) | |
516 | return -ENODEV; | |
517 | ||
518 | if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) | |
519 | return 0; | |
520 | ||
521 | kill_stream_urbs(&ua->capture); | |
522 | ||
523 | err = enable_iso_interface(ua, INTF_CAPTURE); | |
524 | if (err < 0) | |
525 | return err; | |
526 | ||
527 | clear_bit(CAPTURE_URB_COMPLETED, &ua->states); | |
528 | ua->capture.urbs[0]->urb.complete = first_capture_urb_complete; | |
529 | ua->rate_feedback_start = 0; | |
530 | ua->rate_feedback_count = 0; | |
531 | ||
532 | set_bit(USB_CAPTURE_RUNNING, &ua->states); | |
533 | err = submit_stream_urbs(ua, &ua->capture); | |
534 | if (err < 0) | |
535 | stop_usb_capture(ua); | |
536 | return err; | |
537 | } | |
538 | ||
539 | static void stop_usb_playback(struct ua101 *ua) | |
540 | { | |
541 | clear_bit(USB_PLAYBACK_RUNNING, &ua->states); | |
542 | ||
543 | kill_stream_urbs(&ua->playback); | |
544 | ||
545 | tasklet_kill(&ua->playback_tasklet); | |
546 | ||
547 | disable_iso_interface(ua, INTF_PLAYBACK); | |
548 | } | |
549 | ||
550 | static int start_usb_playback(struct ua101 *ua) | |
551 | { | |
552 | unsigned int i, frames; | |
553 | struct urb *urb; | |
554 | int err = 0; | |
555 | ||
556 | if (test_bit(DISCONNECTED, &ua->states)) | |
557 | return -ENODEV; | |
558 | ||
559 | if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) | |
560 | return 0; | |
561 | ||
562 | kill_stream_urbs(&ua->playback); | |
563 | tasklet_kill(&ua->playback_tasklet); | |
564 | ||
565 | err = enable_iso_interface(ua, INTF_PLAYBACK); | |
566 | if (err < 0) | |
567 | return err; | |
568 | ||
569 | clear_bit(PLAYBACK_URB_COMPLETED, &ua->states); | |
570 | ua->playback.urbs[0]->urb.complete = | |
571 | first_playback_urb_complete; | |
572 | spin_lock_irq(&ua->lock); | |
573 | INIT_LIST_HEAD(&ua->ready_playback_urbs); | |
574 | spin_unlock_irq(&ua->lock); | |
575 | ||
576 | /* | |
577 | * We submit the initial URBs all at once, so we have to wait for the | |
578 | * packet size FIFO to be full. | |
579 | */ | |
580 | wait_event(ua->rate_feedback_wait, | |
581 | ua->rate_feedback_count >= ua->playback.queue_length || | |
582 | !test_bit(USB_CAPTURE_RUNNING, &ua->states) || | |
583 | test_bit(DISCONNECTED, &ua->states)); | |
584 | if (test_bit(DISCONNECTED, &ua->states)) { | |
585 | stop_usb_playback(ua); | |
586 | return -ENODEV; | |
587 | } | |
588 | if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) { | |
589 | stop_usb_playback(ua); | |
590 | return -EIO; | |
591 | } | |
592 | ||
593 | for (i = 0; i < ua->playback.queue_length; ++i) { | |
594 | /* all initial URBs contain silence */ | |
595 | spin_lock_irq(&ua->lock); | |
596 | frames = ua->rate_feedback[ua->rate_feedback_start]; | |
597 | add_with_wraparound(ua, &ua->rate_feedback_start, 1); | |
598 | ua->rate_feedback_count--; | |
599 | spin_unlock_irq(&ua->lock); | |
600 | urb = &ua->playback.urbs[i]->urb; | |
601 | urb->iso_frame_desc[0].length = | |
602 | frames * ua->playback.frame_bytes; | |
603 | memset(urb->transfer_buffer, 0, | |
604 | urb->iso_frame_desc[0].length); | |
605 | } | |
606 | ||
607 | set_bit(USB_PLAYBACK_RUNNING, &ua->states); | |
608 | err = submit_stream_urbs(ua, &ua->playback); | |
609 | if (err < 0) | |
610 | stop_usb_playback(ua); | |
611 | return err; | |
612 | } | |
613 | ||
614 | static void abort_alsa_capture(struct ua101 *ua) | |
615 | { | |
616 | if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) | |
617 | snd_pcm_stop(ua->capture.substream, SNDRV_PCM_STATE_XRUN); | |
618 | } | |
619 | ||
620 | static void abort_alsa_playback(struct ua101 *ua) | |
621 | { | |
622 | if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) | |
623 | snd_pcm_stop(ua->playback.substream, SNDRV_PCM_STATE_XRUN); | |
624 | } | |
625 | ||
626 | static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream, | |
627 | unsigned int channels) | |
628 | { | |
629 | int err; | |
630 | ||
631 | substream->runtime->hw.info = | |
632 | SNDRV_PCM_INFO_MMAP | | |
633 | SNDRV_PCM_INFO_MMAP_VALID | | |
634 | SNDRV_PCM_INFO_BATCH | | |
635 | SNDRV_PCM_INFO_INTERLEAVED | | |
636 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
637 | SNDRV_PCM_INFO_FIFO_IN_FRAMES; | |
638 | substream->runtime->hw.formats = ua->format_bit; | |
639 | substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate); | |
640 | substream->runtime->hw.rate_min = ua->rate; | |
641 | substream->runtime->hw.rate_max = ua->rate; | |
642 | substream->runtime->hw.channels_min = channels; | |
643 | substream->runtime->hw.channels_max = channels; | |
644 | substream->runtime->hw.buffer_bytes_max = 45000 * 1024; | |
645 | substream->runtime->hw.period_bytes_min = 1; | |
646 | substream->runtime->hw.period_bytes_max = UINT_MAX; | |
647 | substream->runtime->hw.periods_min = 2; | |
648 | substream->runtime->hw.periods_max = UINT_MAX; | |
649 | err = snd_pcm_hw_constraint_minmax(substream->runtime, | |
650 | SNDRV_PCM_HW_PARAM_PERIOD_TIME, | |
651 | 1500000 / ua->packets_per_second, | |
f4b1e98a | 652 | UINT_MAX); |
63978ab3 CL |
653 | if (err < 0) |
654 | return err; | |
655 | err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24); | |
656 | return err; | |
657 | } | |
658 | ||
659 | static int capture_pcm_open(struct snd_pcm_substream *substream) | |
660 | { | |
661 | struct ua101 *ua = substream->private_data; | |
662 | int err; | |
663 | ||
664 | ua->capture.substream = substream; | |
665 | err = set_stream_hw(ua, substream, ua->capture.channels); | |
666 | if (err < 0) | |
667 | return err; | |
668 | substream->runtime->hw.fifo_size = | |
669 | DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second); | |
670 | substream->runtime->delay = substream->runtime->hw.fifo_size; | |
671 | ||
672 | mutex_lock(&ua->mutex); | |
673 | err = start_usb_capture(ua); | |
674 | if (err >= 0) | |
675 | set_bit(ALSA_CAPTURE_OPEN, &ua->states); | |
676 | mutex_unlock(&ua->mutex); | |
677 | return err; | |
678 | } | |
679 | ||
680 | static int playback_pcm_open(struct snd_pcm_substream *substream) | |
681 | { | |
682 | struct ua101 *ua = substream->private_data; | |
683 | int err; | |
684 | ||
685 | ua->playback.substream = substream; | |
686 | err = set_stream_hw(ua, substream, ua->playback.channels); | |
687 | if (err < 0) | |
688 | return err; | |
689 | substream->runtime->hw.fifo_size = | |
690 | DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length, | |
691 | ua->packets_per_second); | |
692 | ||
693 | mutex_lock(&ua->mutex); | |
694 | err = start_usb_capture(ua); | |
695 | if (err < 0) | |
696 | goto error; | |
697 | err = start_usb_playback(ua); | |
698 | if (err < 0) { | |
699 | if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) | |
700 | stop_usb_capture(ua); | |
701 | goto error; | |
702 | } | |
703 | set_bit(ALSA_PLAYBACK_OPEN, &ua->states); | |
704 | error: | |
705 | mutex_unlock(&ua->mutex); | |
706 | return err; | |
707 | } | |
708 | ||
709 | static int capture_pcm_close(struct snd_pcm_substream *substream) | |
710 | { | |
711 | struct ua101 *ua = substream->private_data; | |
712 | ||
713 | mutex_lock(&ua->mutex); | |
714 | clear_bit(ALSA_CAPTURE_OPEN, &ua->states); | |
715 | if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states)) | |
716 | stop_usb_capture(ua); | |
717 | mutex_unlock(&ua->mutex); | |
718 | return 0; | |
719 | } | |
720 | ||
721 | static int playback_pcm_close(struct snd_pcm_substream *substream) | |
722 | { | |
723 | struct ua101 *ua = substream->private_data; | |
724 | ||
725 | mutex_lock(&ua->mutex); | |
726 | stop_usb_playback(ua); | |
727 | clear_bit(ALSA_PLAYBACK_OPEN, &ua->states); | |
728 | if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) | |
729 | stop_usb_capture(ua); | |
730 | mutex_unlock(&ua->mutex); | |
731 | return 0; | |
732 | } | |
733 | ||
734 | static int capture_pcm_hw_params(struct snd_pcm_substream *substream, | |
735 | struct snd_pcm_hw_params *hw_params) | |
736 | { | |
737 | struct ua101 *ua = substream->private_data; | |
738 | int err; | |
739 | ||
740 | mutex_lock(&ua->mutex); | |
741 | err = start_usb_capture(ua); | |
742 | mutex_unlock(&ua->mutex); | |
743 | if (err < 0) | |
744 | return err; | |
745 | ||
5b4b2a41 CL |
746 | return snd_pcm_lib_alloc_vmalloc_buffer(substream, |
747 | params_buffer_bytes(hw_params)); | |
63978ab3 CL |
748 | } |
749 | ||
750 | static int playback_pcm_hw_params(struct snd_pcm_substream *substream, | |
751 | struct snd_pcm_hw_params *hw_params) | |
752 | { | |
753 | struct ua101 *ua = substream->private_data; | |
754 | int err; | |
755 | ||
756 | mutex_lock(&ua->mutex); | |
757 | err = start_usb_capture(ua); | |
758 | if (err >= 0) | |
759 | err = start_usb_playback(ua); | |
760 | mutex_unlock(&ua->mutex); | |
761 | if (err < 0) | |
762 | return err; | |
763 | ||
5b4b2a41 CL |
764 | return snd_pcm_lib_alloc_vmalloc_buffer(substream, |
765 | params_buffer_bytes(hw_params)); | |
63978ab3 CL |
766 | } |
767 | ||
768 | static int ua101_pcm_hw_free(struct snd_pcm_substream *substream) | |
769 | { | |
5b4b2a41 | 770 | return snd_pcm_lib_free_vmalloc_buffer(substream); |
63978ab3 CL |
771 | } |
772 | ||
773 | static int capture_pcm_prepare(struct snd_pcm_substream *substream) | |
774 | { | |
775 | struct ua101 *ua = substream->private_data; | |
776 | int err; | |
777 | ||
778 | mutex_lock(&ua->mutex); | |
779 | err = start_usb_capture(ua); | |
780 | mutex_unlock(&ua->mutex); | |
781 | if (err < 0) | |
782 | return err; | |
783 | ||
784 | /* | |
785 | * The EHCI driver schedules the first packet of an iso stream at 10 ms | |
786 | * in the future, i.e., no data is actually captured for that long. | |
787 | * Take the wait here so that the stream is known to be actually | |
788 | * running when the start trigger has been called. | |
789 | */ | |
790 | wait_event(ua->alsa_capture_wait, | |
791 | test_bit(CAPTURE_URB_COMPLETED, &ua->states) || | |
792 | !test_bit(USB_CAPTURE_RUNNING, &ua->states)); | |
793 | if (test_bit(DISCONNECTED, &ua->states)) | |
794 | return -ENODEV; | |
795 | if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) | |
796 | return -EIO; | |
797 | ||
798 | ua->capture.period_pos = 0; | |
799 | ua->capture.buffer_pos = 0; | |
800 | return 0; | |
801 | } | |
802 | ||
803 | static int playback_pcm_prepare(struct snd_pcm_substream *substream) | |
804 | { | |
805 | struct ua101 *ua = substream->private_data; | |
806 | int err; | |
807 | ||
808 | mutex_lock(&ua->mutex); | |
809 | err = start_usb_capture(ua); | |
810 | if (err >= 0) | |
811 | err = start_usb_playback(ua); | |
812 | mutex_unlock(&ua->mutex); | |
813 | if (err < 0) | |
814 | return err; | |
815 | ||
816 | /* see the comment in capture_pcm_prepare() */ | |
817 | wait_event(ua->alsa_playback_wait, | |
818 | test_bit(PLAYBACK_URB_COMPLETED, &ua->states) || | |
819 | !test_bit(USB_PLAYBACK_RUNNING, &ua->states)); | |
820 | if (test_bit(DISCONNECTED, &ua->states)) | |
821 | return -ENODEV; | |
822 | if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) | |
823 | return -EIO; | |
824 | ||
825 | substream->runtime->delay = 0; | |
826 | ua->playback.period_pos = 0; | |
827 | ua->playback.buffer_pos = 0; | |
828 | return 0; | |
829 | } | |
830 | ||
831 | static int capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd) | |
832 | { | |
833 | struct ua101 *ua = substream->private_data; | |
834 | ||
835 | switch (cmd) { | |
836 | case SNDRV_PCM_TRIGGER_START: | |
837 | if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) | |
838 | return -EIO; | |
839 | set_bit(ALSA_CAPTURE_RUNNING, &ua->states); | |
840 | return 0; | |
841 | case SNDRV_PCM_TRIGGER_STOP: | |
842 | clear_bit(ALSA_CAPTURE_RUNNING, &ua->states); | |
843 | return 0; | |
844 | default: | |
845 | return -EINVAL; | |
846 | } | |
847 | } | |
848 | ||
849 | static int playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd) | |
850 | { | |
851 | struct ua101 *ua = substream->private_data; | |
852 | ||
853 | switch (cmd) { | |
854 | case SNDRV_PCM_TRIGGER_START: | |
855 | if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) | |
856 | return -EIO; | |
857 | set_bit(ALSA_PLAYBACK_RUNNING, &ua->states); | |
858 | return 0; | |
859 | case SNDRV_PCM_TRIGGER_STOP: | |
860 | clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states); | |
861 | return 0; | |
862 | default: | |
863 | return -EINVAL; | |
864 | } | |
865 | } | |
866 | ||
867 | static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua, | |
868 | struct ua101_stream *stream) | |
869 | { | |
870 | unsigned long flags; | |
871 | unsigned int pos; | |
872 | ||
873 | spin_lock_irqsave(&ua->lock, flags); | |
874 | pos = stream->buffer_pos; | |
875 | spin_unlock_irqrestore(&ua->lock, flags); | |
876 | return pos; | |
877 | } | |
878 | ||
879 | static snd_pcm_uframes_t capture_pcm_pointer(struct snd_pcm_substream *subs) | |
880 | { | |
881 | struct ua101 *ua = subs->private_data; | |
882 | ||
883 | return ua101_pcm_pointer(ua, &ua->capture); | |
884 | } | |
885 | ||
886 | static snd_pcm_uframes_t playback_pcm_pointer(struct snd_pcm_substream *subs) | |
887 | { | |
888 | struct ua101 *ua = subs->private_data; | |
889 | ||
890 | return ua101_pcm_pointer(ua, &ua->playback); | |
891 | } | |
892 | ||
893 | static struct snd_pcm_ops capture_pcm_ops = { | |
894 | .open = capture_pcm_open, | |
895 | .close = capture_pcm_close, | |
896 | .ioctl = snd_pcm_lib_ioctl, | |
897 | .hw_params = capture_pcm_hw_params, | |
898 | .hw_free = ua101_pcm_hw_free, | |
899 | .prepare = capture_pcm_prepare, | |
900 | .trigger = capture_pcm_trigger, | |
901 | .pointer = capture_pcm_pointer, | |
5b4b2a41 | 902 | .page = snd_pcm_lib_get_vmalloc_page, |
c32d977b | 903 | .mmap = snd_pcm_lib_mmap_vmalloc, |
63978ab3 CL |
904 | }; |
905 | ||
906 | static struct snd_pcm_ops playback_pcm_ops = { | |
907 | .open = playback_pcm_open, | |
908 | .close = playback_pcm_close, | |
909 | .ioctl = snd_pcm_lib_ioctl, | |
910 | .hw_params = playback_pcm_hw_params, | |
911 | .hw_free = ua101_pcm_hw_free, | |
912 | .prepare = playback_pcm_prepare, | |
913 | .trigger = playback_pcm_trigger, | |
914 | .pointer = playback_pcm_pointer, | |
5b4b2a41 | 915 | .page = snd_pcm_lib_get_vmalloc_page, |
c32d977b | 916 | .mmap = snd_pcm_lib_mmap_vmalloc, |
63978ab3 CL |
917 | }; |
918 | ||
919 | static const struct uac_format_type_i_discrete_descriptor * | |
920 | find_format_descriptor(struct usb_interface *interface) | |
921 | { | |
922 | struct usb_host_interface *alt; | |
923 | u8 *extra; | |
924 | int extralen; | |
925 | ||
926 | if (interface->num_altsetting != 2) { | |
927 | dev_err(&interface->dev, "invalid num_altsetting\n"); | |
928 | return NULL; | |
929 | } | |
930 | ||
931 | alt = &interface->altsetting[0]; | |
932 | if (alt->desc.bNumEndpoints != 0) { | |
933 | dev_err(&interface->dev, "invalid bNumEndpoints\n"); | |
934 | return NULL; | |
935 | } | |
936 | ||
937 | alt = &interface->altsetting[1]; | |
938 | if (alt->desc.bNumEndpoints != 1) { | |
939 | dev_err(&interface->dev, "invalid bNumEndpoints\n"); | |
940 | return NULL; | |
941 | } | |
942 | ||
943 | extra = alt->extra; | |
944 | extralen = alt->extralen; | |
945 | while (extralen >= sizeof(struct usb_descriptor_header)) { | |
946 | struct uac_format_type_i_discrete_descriptor *desc; | |
947 | ||
948 | desc = (struct uac_format_type_i_discrete_descriptor *)extra; | |
949 | if (desc->bLength > extralen) { | |
950 | dev_err(&interface->dev, "descriptor overflow\n"); | |
951 | return NULL; | |
952 | } | |
953 | if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) && | |
954 | desc->bDescriptorType == USB_DT_CS_INTERFACE && | |
955 | desc->bDescriptorSubtype == UAC_FORMAT_TYPE) { | |
956 | if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM || | |
957 | desc->bSamFreqType != 1) { | |
958 | dev_err(&interface->dev, | |
959 | "invalid format type\n"); | |
960 | return NULL; | |
961 | } | |
962 | return desc; | |
963 | } | |
964 | extralen -= desc->bLength; | |
965 | extra += desc->bLength; | |
966 | } | |
967 | dev_err(&interface->dev, "sample format descriptor not found\n"); | |
968 | return NULL; | |
969 | } | |
970 | ||
971 | static int detect_usb_format(struct ua101 *ua) | |
972 | { | |
973 | const struct uac_format_type_i_discrete_descriptor *fmt_capture; | |
974 | const struct uac_format_type_i_discrete_descriptor *fmt_playback; | |
975 | const struct usb_endpoint_descriptor *epd; | |
976 | unsigned int rate2; | |
977 | ||
978 | fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]); | |
979 | fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]); | |
980 | if (!fmt_capture || !fmt_playback) | |
981 | return -ENXIO; | |
982 | ||
983 | switch (fmt_capture->bSubframeSize) { | |
984 | case 3: | |
985 | ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE; | |
986 | break; | |
987 | case 4: | |
988 | ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE; | |
989 | break; | |
990 | default: | |
991 | dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n"); | |
992 | return -ENXIO; | |
993 | } | |
994 | if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) { | |
995 | dev_err(&ua->dev->dev, | |
996 | "playback/capture sample widths do not match\n"); | |
997 | return -ENXIO; | |
998 | } | |
999 | ||
1000 | if (fmt_capture->bBitResolution != 24 || | |
1001 | fmt_playback->bBitResolution != 24) { | |
1002 | dev_err(&ua->dev->dev, "sample width is not 24 bits\n"); | |
1003 | return -ENXIO; | |
1004 | } | |
1005 | ||
1006 | ua->rate = combine_triple(fmt_capture->tSamFreq[0]); | |
1007 | rate2 = combine_triple(fmt_playback->tSamFreq[0]); | |
1008 | if (ua->rate != rate2) { | |
1009 | dev_err(&ua->dev->dev, | |
1010 | "playback/capture rates do not match: %u/%u\n", | |
1011 | rate2, ua->rate); | |
1012 | return -ENXIO; | |
1013 | } | |
1014 | ||
1015 | switch (ua->dev->speed) { | |
1016 | case USB_SPEED_FULL: | |
1017 | ua->packets_per_second = 1000; | |
1018 | break; | |
1019 | case USB_SPEED_HIGH: | |
1020 | ua->packets_per_second = 8000; | |
1021 | break; | |
1022 | default: | |
1023 | dev_err(&ua->dev->dev, "unknown device speed\n"); | |
1024 | return -ENXIO; | |
1025 | } | |
1026 | ||
1027 | ua->capture.channels = fmt_capture->bNrChannels; | |
1028 | ua->playback.channels = fmt_playback->bNrChannels; | |
1029 | ua->capture.frame_bytes = | |
1030 | fmt_capture->bSubframeSize * ua->capture.channels; | |
1031 | ua->playback.frame_bytes = | |
1032 | fmt_playback->bSubframeSize * ua->playback.channels; | |
1033 | ||
1034 | epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc; | |
1035 | if (!usb_endpoint_is_isoc_in(epd)) { | |
1036 | dev_err(&ua->dev->dev, "invalid capture endpoint\n"); | |
1037 | return -ENXIO; | |
1038 | } | |
1039 | ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd)); | |
1040 | ua->capture.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize); | |
1041 | ||
1042 | epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc; | |
1043 | if (!usb_endpoint_is_isoc_out(epd)) { | |
1044 | dev_err(&ua->dev->dev, "invalid playback endpoint\n"); | |
1045 | return -ENXIO; | |
1046 | } | |
1047 | ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd)); | |
1048 | ua->playback.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize); | |
1049 | return 0; | |
1050 | } | |
1051 | ||
1052 | static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) | |
1053 | { | |
1054 | unsigned int remaining_packets, packets, packets_per_page, i; | |
1055 | size_t size; | |
1056 | ||
1057 | stream->queue_length = queue_length; | |
1058 | stream->queue_length = max(stream->queue_length, | |
1059 | (unsigned int)MIN_QUEUE_LENGTH); | |
1060 | stream->queue_length = min(stream->queue_length, | |
1061 | (unsigned int)MAX_QUEUE_LENGTH); | |
1062 | ||
1063 | /* | |
997ea58e | 1064 | * The cache pool sizes used by usb_alloc_coherent() (128, 512, 2048) are |
63978ab3 CL |
1065 | * quite bad when used with the packet sizes of this device (e.g. 280, |
1066 | * 520, 624). Therefore, we allocate and subdivide entire pages, using | |
1067 | * a smaller buffer only for the last chunk. | |
1068 | */ | |
1069 | remaining_packets = stream->queue_length; | |
1070 | packets_per_page = PAGE_SIZE / stream->max_packet_bytes; | |
1071 | for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) { | |
1072 | packets = min(remaining_packets, packets_per_page); | |
1073 | size = packets * stream->max_packet_bytes; | |
1074 | stream->buffers[i].addr = | |
997ea58e DM |
1075 | usb_alloc_coherent(ua->dev, size, GFP_KERNEL, |
1076 | &stream->buffers[i].dma); | |
63978ab3 CL |
1077 | if (!stream->buffers[i].addr) |
1078 | return -ENOMEM; | |
1079 | stream->buffers[i].size = size; | |
1080 | remaining_packets -= packets; | |
1081 | if (!remaining_packets) | |
1082 | break; | |
1083 | } | |
1084 | if (remaining_packets) { | |
1085 | dev_err(&ua->dev->dev, "too many packets\n"); | |
1086 | return -ENXIO; | |
1087 | } | |
1088 | return 0; | |
1089 | } | |
1090 | ||
1091 | static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) | |
1092 | { | |
1093 | unsigned int i; | |
1094 | ||
1095 | for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) | |
997ea58e DM |
1096 | usb_free_coherent(ua->dev, |
1097 | stream->buffers[i].size, | |
1098 | stream->buffers[i].addr, | |
1099 | stream->buffers[i].dma); | |
63978ab3 CL |
1100 | } |
1101 | ||
1102 | static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream, | |
1103 | void (*urb_complete)(struct urb *)) | |
1104 | { | |
1105 | unsigned max_packet_size = stream->max_packet_bytes; | |
1106 | struct ua101_urb *urb; | |
1107 | unsigned int b, u = 0; | |
1108 | ||
1109 | for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) { | |
1110 | unsigned int size = stream->buffers[b].size; | |
1111 | u8 *addr = stream->buffers[b].addr; | |
1112 | dma_addr_t dma = stream->buffers[b].dma; | |
1113 | ||
1114 | while (size >= max_packet_size) { | |
1115 | if (u >= stream->queue_length) | |
1116 | goto bufsize_error; | |
1117 | urb = kmalloc(sizeof(*urb), GFP_KERNEL); | |
1118 | if (!urb) | |
1119 | return -ENOMEM; | |
1120 | usb_init_urb(&urb->urb); | |
1121 | urb->urb.dev = ua->dev; | |
1122 | urb->urb.pipe = stream->usb_pipe; | |
1123 | urb->urb.transfer_flags = URB_ISO_ASAP | | |
1124 | URB_NO_TRANSFER_DMA_MAP; | |
1125 | urb->urb.transfer_buffer = addr; | |
1126 | urb->urb.transfer_dma = dma; | |
1127 | urb->urb.transfer_buffer_length = max_packet_size; | |
1128 | urb->urb.number_of_packets = 1; | |
1129 | urb->urb.interval = 1; | |
1130 | urb->urb.context = ua; | |
1131 | urb->urb.complete = urb_complete; | |
1132 | urb->urb.iso_frame_desc[0].offset = 0; | |
1133 | urb->urb.iso_frame_desc[0].length = max_packet_size; | |
1134 | stream->urbs[u++] = urb; | |
1135 | size -= max_packet_size; | |
1136 | addr += max_packet_size; | |
1137 | dma += max_packet_size; | |
1138 | } | |
1139 | } | |
1140 | if (u == stream->queue_length) | |
1141 | return 0; | |
1142 | bufsize_error: | |
1143 | dev_err(&ua->dev->dev, "internal buffer size error\n"); | |
1144 | return -ENXIO; | |
1145 | } | |
1146 | ||
1147 | static void free_stream_urbs(struct ua101_stream *stream) | |
1148 | { | |
1149 | unsigned int i; | |
1150 | ||
862a6244 | 1151 | for (i = 0; i < stream->queue_length; ++i) { |
63978ab3 | 1152 | kfree(stream->urbs[i]); |
862a6244 CL |
1153 | stream->urbs[i] = NULL; |
1154 | } | |
63978ab3 CL |
1155 | } |
1156 | ||
1157 | static void free_usb_related_resources(struct ua101 *ua, | |
1158 | struct usb_interface *interface) | |
1159 | { | |
1160 | unsigned int i; | |
862a6244 | 1161 | struct usb_interface *intf; |
63978ab3 | 1162 | |
862a6244 | 1163 | mutex_lock(&ua->mutex); |
63978ab3 CL |
1164 | free_stream_urbs(&ua->capture); |
1165 | free_stream_urbs(&ua->playback); | |
862a6244 | 1166 | mutex_unlock(&ua->mutex); |
63978ab3 CL |
1167 | free_stream_buffers(ua, &ua->capture); |
1168 | free_stream_buffers(ua, &ua->playback); | |
1169 | ||
862a6244 CL |
1170 | for (i = 0; i < ARRAY_SIZE(ua->intf); ++i) { |
1171 | mutex_lock(&ua->mutex); | |
1172 | intf = ua->intf[i]; | |
1173 | ua->intf[i] = NULL; | |
1174 | mutex_unlock(&ua->mutex); | |
1175 | if (intf) { | |
1176 | usb_set_intfdata(intf, NULL); | |
1177 | if (intf != interface) | |
63978ab3 | 1178 | usb_driver_release_interface(&ua101_driver, |
862a6244 | 1179 | intf); |
63978ab3 | 1180 | } |
862a6244 | 1181 | } |
63978ab3 CL |
1182 | } |
1183 | ||
1184 | static void ua101_card_free(struct snd_card *card) | |
1185 | { | |
1186 | struct ua101 *ua = card->private_data; | |
1187 | ||
1188 | mutex_destroy(&ua->mutex); | |
1189 | } | |
1190 | ||
1191 | static int ua101_probe(struct usb_interface *interface, | |
1192 | const struct usb_device_id *usb_id) | |
1193 | { | |
1194 | static const struct snd_usb_midi_endpoint_info midi_ep = { | |
1195 | .out_cables = 0x0001, | |
1196 | .in_cables = 0x0001 | |
1197 | }; | |
1198 | static const struct snd_usb_audio_quirk midi_quirk = { | |
1199 | .type = QUIRK_MIDI_FIXED_ENDPOINT, | |
1200 | .data = &midi_ep | |
1201 | }; | |
e584bc3c CL |
1202 | static const int intf_numbers[2][3] = { |
1203 | { /* UA-101 */ | |
1204 | [INTF_PLAYBACK] = 0, | |
1205 | [INTF_CAPTURE] = 1, | |
1206 | [INTF_MIDI] = 2, | |
1207 | }, | |
1208 | { /* UA-1000 */ | |
1209 | [INTF_CAPTURE] = 1, | |
1210 | [INTF_PLAYBACK] = 2, | |
1211 | [INTF_MIDI] = 3, | |
1212 | }, | |
1213 | }; | |
63978ab3 CL |
1214 | struct snd_card *card; |
1215 | struct ua101 *ua; | |
1216 | unsigned int card_index, i; | |
e584bc3c CL |
1217 | int is_ua1000; |
1218 | const char *name; | |
63978ab3 CL |
1219 | char usb_path[32]; |
1220 | int err; | |
1221 | ||
e584bc3c CL |
1222 | is_ua1000 = usb_id->idProduct == 0x0044; |
1223 | ||
1224 | if (interface->altsetting->desc.bInterfaceNumber != | |
1225 | intf_numbers[is_ua1000][0]) | |
63978ab3 CL |
1226 | return -ENODEV; |
1227 | ||
1228 | mutex_lock(&devices_mutex); | |
1229 | ||
1230 | for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) | |
1231 | if (enable[card_index] && !(devices_used & (1 << card_index))) | |
1232 | break; | |
1233 | if (card_index >= SNDRV_CARDS) { | |
1234 | mutex_unlock(&devices_mutex); | |
1235 | return -ENOENT; | |
1236 | } | |
1237 | err = snd_card_create(index[card_index], id[card_index], THIS_MODULE, | |
1238 | sizeof(*ua), &card); | |
1239 | if (err < 0) { | |
1240 | mutex_unlock(&devices_mutex); | |
1241 | return err; | |
1242 | } | |
1243 | card->private_free = ua101_card_free; | |
1244 | ua = card->private_data; | |
1245 | ua->dev = interface_to_usbdev(interface); | |
1246 | ua->card = card; | |
1247 | ua->card_index = card_index; | |
1248 | INIT_LIST_HEAD(&ua->midi_list); | |
1249 | spin_lock_init(&ua->lock); | |
1250 | mutex_init(&ua->mutex); | |
1251 | INIT_LIST_HEAD(&ua->ready_playback_urbs); | |
1252 | tasklet_init(&ua->playback_tasklet, | |
1253 | playback_tasklet, (unsigned long)ua); | |
1254 | init_waitqueue_head(&ua->alsa_capture_wait); | |
1255 | init_waitqueue_head(&ua->rate_feedback_wait); | |
1256 | init_waitqueue_head(&ua->alsa_playback_wait); | |
1257 | ||
63978ab3 CL |
1258 | ua->intf[0] = interface; |
1259 | for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) { | |
e584bc3c CL |
1260 | ua->intf[i] = usb_ifnum_to_if(ua->dev, |
1261 | intf_numbers[is_ua1000][i]); | |
63978ab3 | 1262 | if (!ua->intf[i]) { |
e584bc3c CL |
1263 | dev_err(&ua->dev->dev, "interface %u not found\n", |
1264 | intf_numbers[is_ua1000][i]); | |
63978ab3 CL |
1265 | err = -ENXIO; |
1266 | goto probe_error; | |
1267 | } | |
1268 | err = usb_driver_claim_interface(&ua101_driver, | |
1269 | ua->intf[i], ua); | |
1270 | if (err < 0) { | |
1271 | ua->intf[i] = NULL; | |
1272 | err = -EBUSY; | |
1273 | goto probe_error; | |
1274 | } | |
1275 | } | |
63978ab3 CL |
1276 | |
1277 | snd_card_set_dev(card, &interface->dev); | |
1278 | ||
63978ab3 CL |
1279 | err = detect_usb_format(ua); |
1280 | if (err < 0) | |
1281 | goto probe_error; | |
63978ab3 | 1282 | |
e584bc3c | 1283 | name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101"; |
63978ab3 | 1284 | strcpy(card->driver, "UA-101"); |
e584bc3c | 1285 | strcpy(card->shortname, name); |
63978ab3 CL |
1286 | usb_make_path(ua->dev, usb_path, sizeof(usb_path)); |
1287 | snprintf(ua->card->longname, sizeof(ua->card->longname), | |
e584bc3c | 1288 | "EDIROL %s (serial %s), %u Hz at %s, %s speed", name, |
63978ab3 CL |
1289 | ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path, |
1290 | ua->dev->speed == USB_SPEED_HIGH ? "high" : "full"); | |
1291 | ||
1292 | err = alloc_stream_buffers(ua, &ua->capture); | |
1293 | if (err < 0) | |
1294 | goto probe_error; | |
1295 | err = alloc_stream_buffers(ua, &ua->playback); | |
1296 | if (err < 0) | |
1297 | goto probe_error; | |
1298 | ||
1299 | err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete); | |
1300 | if (err < 0) | |
1301 | goto probe_error; | |
1302 | err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete); | |
1303 | if (err < 0) | |
1304 | goto probe_error; | |
1305 | ||
e584bc3c | 1306 | err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm); |
63978ab3 CL |
1307 | if (err < 0) |
1308 | goto probe_error; | |
1309 | ua->pcm->private_data = ua; | |
e584bc3c | 1310 | strcpy(ua->pcm->name, name); |
63978ab3 CL |
1311 | snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops); |
1312 | snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops); | |
1313 | ||
63978ab3 CL |
1314 | err = snd_usbmidi_create(card, ua->intf[INTF_MIDI], |
1315 | &ua->midi_list, &midi_quirk); | |
1316 | if (err < 0) | |
1317 | goto probe_error; | |
63978ab3 CL |
1318 | |
1319 | err = snd_card_register(card); | |
1320 | if (err < 0) | |
1321 | goto probe_error; | |
1322 | ||
1323 | usb_set_intfdata(interface, ua); | |
1324 | devices_used |= 1 << card_index; | |
1325 | ||
1326 | mutex_unlock(&devices_mutex); | |
1327 | return 0; | |
1328 | ||
1329 | probe_error: | |
1330 | free_usb_related_resources(ua, interface); | |
1331 | snd_card_free(card); | |
1332 | mutex_unlock(&devices_mutex); | |
1333 | return err; | |
1334 | } | |
1335 | ||
1336 | static void ua101_disconnect(struct usb_interface *interface) | |
1337 | { | |
1338 | struct ua101 *ua = usb_get_intfdata(interface); | |
1339 | struct list_head *midi; | |
1340 | ||
1341 | if (!ua) | |
1342 | return; | |
1343 | ||
1344 | mutex_lock(&devices_mutex); | |
1345 | ||
1346 | set_bit(DISCONNECTED, &ua->states); | |
1347 | wake_up(&ua->rate_feedback_wait); | |
1348 | ||
1349 | /* make sure that userspace cannot create new requests */ | |
1350 | snd_card_disconnect(ua->card); | |
1351 | ||
1352 | /* make sure that there are no pending USB requests */ | |
1353 | __list_for_each(midi, &ua->midi_list) | |
1354 | snd_usbmidi_disconnect(midi); | |
1355 | abort_alsa_playback(ua); | |
1356 | abort_alsa_capture(ua); | |
1357 | mutex_lock(&ua->mutex); | |
1358 | stop_usb_playback(ua); | |
1359 | stop_usb_capture(ua); | |
1360 | mutex_unlock(&ua->mutex); | |
1361 | ||
1362 | free_usb_related_resources(ua, interface); | |
1363 | ||
1364 | devices_used &= ~(1 << ua->card_index); | |
1365 | ||
1366 | snd_card_free_when_closed(ua->card); | |
1367 | ||
1368 | mutex_unlock(&devices_mutex); | |
1369 | } | |
1370 | ||
1371 | static struct usb_device_id ua101_ids[] = { | |
e584bc3c CL |
1372 | { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */ |
1373 | { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */ | |
1374 | { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */ | |
63978ab3 CL |
1375 | { } |
1376 | }; | |
1377 | MODULE_DEVICE_TABLE(usb, ua101_ids); | |
1378 | ||
1379 | static struct usb_driver ua101_driver = { | |
1380 | .name = "snd-ua101", | |
1381 | .id_table = ua101_ids, | |
1382 | .probe = ua101_probe, | |
1383 | .disconnect = ua101_disconnect, | |
1384 | #if 0 | |
1385 | .suspend = ua101_suspend, | |
1386 | .resume = ua101_resume, | |
1387 | #endif | |
1388 | }; | |
1389 | ||
1390 | static int __init alsa_card_ua101_init(void) | |
1391 | { | |
1392 | return usb_register(&ua101_driver); | |
1393 | } | |
1394 | ||
1395 | static void __exit alsa_card_ua101_exit(void) | |
1396 | { | |
1397 | usb_deregister(&ua101_driver); | |
1398 | mutex_destroy(&devices_mutex); | |
1399 | } | |
1400 | ||
1401 | module_init(alsa_card_ua101_init); | |
1402 | module_exit(alsa_card_ua101_exit); |