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