Lines Matching +full:30 +full:ua
3 * Edirol UA-101/UA-1000 driver
19 MODULE_DESCRIPTION("Edirol UA-101/1000 driver");
30 #define MAX_QUEUE_LENGTH 30
32 * This magic value optimizes memory usage efficiency for the UA-101's packet
128 static void abort_alsa_playback(struct ua101 *ua);
129 static void abort_alsa_capture(struct ua101 *ua);
156 static void abort_usb_capture(struct ua101 *ua)
158 if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) {
159 wake_up(&ua->alsa_capture_wait);
160 wake_up(&ua->rate_feedback_wait);
164 static void abort_usb_playback(struct ua101 *ua)
166 if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states))
167 wake_up(&ua->alsa_playback_wait);
173 struct ua101 *ua = urb->urb.context;
179 abort_usb_playback(ua);
180 abort_alsa_playback(ua);
184 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) {
186 guard(spinlock_irqsave)(&ua->lock);
187 list_add_tail(&urb->ready_list, &ua->ready_playback_urbs);
188 if (ua->rate_feedback_count > 0)
189 queue_work(system_highpri_wq, &ua->playback_work);
190 ua->playback.substream->runtime->delay -=
192 ua->playback.frame_bytes;
198 struct ua101 *ua = urb->context;
203 set_bit(PLAYBACK_URB_COMPLETED, &ua->states);
204 wake_up(&ua->alsa_playback_wait);
239 static inline void add_with_wraparound(struct ua101 *ua,
243 if (*value >= ua->playback.queue_length)
244 *value -= ua->playback.queue_length;
249 struct ua101 *ua = container_of(work, struct ua101, playback_work);
255 if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
269 scoped_guard(spinlock_irqsave, &ua->lock) {
270 while (ua->rate_feedback_count > 0 &&
271 !list_empty(&ua->ready_playback_urbs)) {
273 frames = ua->rate_feedback[ua->rate_feedback_start];
274 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
275 ua->rate_feedback_count--;
278 urb = list_first_entry(&ua->ready_playback_urbs,
284 frames * ua->playback.frame_bytes;
285 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
286 do_period_elapsed |= copy_playback_data(&ua->playback,
296 abort_usb_playback(ua);
297 abort_alsa_playback(ua);
298 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
302 ua->playback.substream->runtime->delay += frames;
307 snd_pcm_period_elapsed(ua->playback.substream);
345 struct ua101 *ua = urb->context;
346 struct ua101_stream *stream = &ua->capture;
363 scoped_guard(spinlock_irqsave, &ua->lock) {
365 if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
370 if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
373 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
379 write_ptr = ua->rate_feedback_start;
380 add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count);
381 ua->rate_feedback[write_ptr] = frames;
382 if (ua->rate_feedback_count < ua->playback.queue_length) {
383 ua->rate_feedback_count++;
384 if (ua->rate_feedback_count ==
385 ua->playback.queue_length)
386 wake_up(&ua->rate_feedback_wait);
394 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
396 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
397 !list_empty(&ua->ready_playback_urbs))
398 queue_work(system_highpri_wq, &ua->playback_work);
408 abort_usb_playback(ua);
409 abort_usb_capture(ua);
410 abort_alsa_playback(ua);
411 abort_alsa_capture(ua);
416 struct ua101 *ua = urb->context;
421 set_bit(CAPTURE_URB_COMPLETED, &ua->states);
422 wake_up(&ua->alsa_capture_wait);
425 static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
432 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
449 static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
453 alts = ua->intf[intf_index]->cur_altsetting;
455 int err = usb_set_interface(ua->dev,
458 dev_err(&ua->dev->dev,
467 static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
471 if (!ua->intf[intf_index])
474 alts = ua->intf[intf_index]->cur_altsetting;
476 int err = usb_set_interface(ua->dev,
478 if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
479 dev_warn(&ua->dev->dev,
485 static void stop_usb_capture(struct ua101 *ua)
487 clear_bit(USB_CAPTURE_RUNNING, &ua->states);
489 kill_stream_urbs(&ua->capture);
491 disable_iso_interface(ua, INTF_CAPTURE);
494 static int start_usb_capture(struct ua101 *ua)
498 if (test_bit(DISCONNECTED, &ua->states))
501 if (test_bit(USB_CAPTURE_RUNNING, &ua->states))
504 kill_stream_urbs(&ua->capture);
506 err = enable_iso_interface(ua, INTF_CAPTURE);
510 clear_bit(CAPTURE_URB_COMPLETED, &ua->states);
511 ua->capture.urbs[0]->urb.complete = first_capture_urb_complete;
512 ua->rate_feedback_start = 0;
513 ua->rate_feedback_count = 0;
515 set_bit(USB_CAPTURE_RUNNING, &ua->states);
516 err = submit_stream_urbs(ua, &ua->capture);
518 stop_usb_capture(ua);
522 static void stop_usb_playback(struct ua101 *ua)
524 clear_bit(USB_PLAYBACK_RUNNING, &ua->states);
526 kill_stream_urbs(&ua->playback);
528 cancel_work_sync(&ua->playback_work);
530 disable_iso_interface(ua, INTF_PLAYBACK);
533 static int start_usb_playback(struct ua101 *ua)
539 if (test_bit(DISCONNECTED, &ua->states))
542 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states))
545 kill_stream_urbs(&ua->playback);
546 cancel_work_sync(&ua->playback_work);
548 err = enable_iso_interface(ua, INTF_PLAYBACK);
552 clear_bit(PLAYBACK_URB_COMPLETED, &ua->states);
553 ua->playback.urbs[0]->urb.complete =
555 scoped_guard(spinlock_irq, &ua->lock) {
556 INIT_LIST_HEAD(&ua->ready_playback_urbs);
563 wait_event(ua->rate_feedback_wait,
564 ua->rate_feedback_count >= ua->playback.queue_length ||
565 !test_bit(USB_CAPTURE_RUNNING, &ua->states) ||
566 test_bit(DISCONNECTED, &ua->states));
567 if (test_bit(DISCONNECTED, &ua->states)) {
568 stop_usb_playback(ua);
571 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
572 stop_usb_playback(ua);
576 for (i = 0; i < ua->playback.queue_length; ++i) {
578 scoped_guard(spinlock_irq, &ua->lock) {
579 frames = ua->rate_feedback[ua->rate_feedback_start];
580 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
581 ua->rate_feedback_count--;
583 urb = &ua->playback.urbs[i]->urb;
585 frames * ua->playback.frame_bytes;
590 set_bit(USB_PLAYBACK_RUNNING, &ua->states);
591 err = submit_stream_urbs(ua, &ua->playback);
593 stop_usb_playback(ua);
597 static void abort_alsa_capture(struct ua101 *ua)
599 if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
600 snd_pcm_stop_xrun(ua->capture.substream);
603 static void abort_alsa_playback(struct ua101 *ua)
605 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
606 snd_pcm_stop_xrun(ua->playback.substream);
609 static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream,
621 substream->runtime->hw.formats = ua->format_bit;
622 substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate);
623 substream->runtime->hw.rate_min = ua->rate;
624 substream->runtime->hw.rate_max = ua->rate;
634 1500000 / ua->packets_per_second,
644 struct ua101 *ua = substream->private_data;
647 ua->capture.substream = substream;
648 err = set_stream_hw(ua, substream, ua->capture.channels);
652 DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second);
655 guard(mutex)(&ua->mutex);
656 err = start_usb_capture(ua);
658 set_bit(ALSA_CAPTURE_OPEN, &ua->states);
664 struct ua101 *ua = substream->private_data;
667 ua->playback.substream = substream;
668 err = set_stream_hw(ua, substream, ua->playback.channels);
672 DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length,
673 ua->packets_per_second);
675 guard(mutex)(&ua->mutex);
676 err = start_usb_capture(ua);
679 err = start_usb_playback(ua);
681 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
682 stop_usb_capture(ua);
685 set_bit(ALSA_PLAYBACK_OPEN, &ua->states);
691 struct ua101 *ua = substream->private_data;
693 guard(mutex)(&ua->mutex);
694 clear_bit(ALSA_CAPTURE_OPEN, &ua->states);
695 if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states))
696 stop_usb_capture(ua);
702 struct ua101 *ua = substream->private_data;
704 guard(mutex)(&ua->mutex);
705 stop_usb_playback(ua);
706 clear_bit(ALSA_PLAYBACK_OPEN, &ua->states);
707 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
708 stop_usb_capture(ua);
715 struct ua101 *ua = substream->private_data;
717 guard(mutex)(&ua->mutex);
718 return start_usb_capture(ua);
724 struct ua101 *ua = substream->private_data;
727 guard(mutex)(&ua->mutex);
728 err = start_usb_capture(ua);
730 err = start_usb_playback(ua);
736 struct ua101 *ua = substream->private_data;
739 scoped_guard(mutex, &ua->mutex) {
740 err = start_usb_capture(ua);
751 wait_event(ua->alsa_capture_wait,
752 test_bit(CAPTURE_URB_COMPLETED, &ua->states) ||
753 !test_bit(USB_CAPTURE_RUNNING, &ua->states));
754 if (test_bit(DISCONNECTED, &ua->states))
756 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
759 ua->capture.period_pos = 0;
760 ua->capture.buffer_pos = 0;
766 struct ua101 *ua = substream->private_data;
769 scoped_guard(mutex, &ua->mutex) {
770 err = start_usb_capture(ua);
772 err = start_usb_playback(ua);
778 wait_event(ua->alsa_playback_wait,
779 test_bit(PLAYBACK_URB_COMPLETED, &ua->states) ||
780 !test_bit(USB_PLAYBACK_RUNNING, &ua->states));
781 if (test_bit(DISCONNECTED, &ua->states))
783 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
787 ua->playback.period_pos = 0;
788 ua->playback.buffer_pos = 0;
794 struct ua101 *ua = substream->private_data;
798 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
800 set_bit(ALSA_CAPTURE_RUNNING, &ua->states);
803 clear_bit(ALSA_CAPTURE_RUNNING, &ua->states);
812 struct ua101 *ua = substream->private_data;
816 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
818 set_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
821 clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
828 static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua,
831 guard(spinlock_irqsave)(&ua->lock);
837 struct ua101 *ua = subs->private_data;
839 return ua101_pcm_pointer(ua, &ua->capture);
844 struct ua101 *ua = subs->private_data;
846 return ua101_pcm_pointer(ua, &ua->playback);
919 static int detect_usb_format(struct ua101 *ua)
926 fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]);
927 fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]);
933 ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE;
936 ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE;
939 dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n");
943 dev_err(&ua->dev->dev,
950 dev_err(&ua->dev->dev, "sample width is not 24 bits\n");
954 ua->rate = combine_triple(fmt_capture->tSamFreq[0]);
956 if (ua->rate != rate2) {
957 dev_err(&ua->dev->dev,
959 rate2, ua->rate);
963 switch (ua->dev->speed) {
965 ua->packets_per_second = 1000;
968 ua->packets_per_second = 8000;
971 dev_err(&ua->dev->dev, "unknown device speed\n");
975 ua->capture.channels = fmt_capture->bNrChannels;
976 ua->playback.channels = fmt_playback->bNrChannels;
977 ua->capture.frame_bytes =
978 fmt_capture->bSubframeSize * ua->capture.channels;
979 ua->playback.frame_bytes =
980 fmt_playback->bSubframeSize * ua->playback.channels;
982 epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc;
984 dev_err(&ua->dev->dev, "invalid capture endpoint\n");
987 ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd));
988 ua->capture.max_packet_bytes = usb_endpoint_maxp(epd);
990 epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc;
992 dev_err(&ua->dev->dev, "invalid playback endpoint\n");
995 ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd));
996 ua->playback.max_packet_bytes = usb_endpoint_maxp(epd);
1000 static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1023 usb_alloc_coherent(ua->dev, size, GFP_KERNEL,
1033 dev_err(&ua->dev->dev, "too many packets\n");
1039 static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1044 usb_free_coherent(ua->dev,
1050 static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
1069 urb->urb.dev = ua->dev;
1077 urb->urb.context = ua;
1090 dev_err(&ua->dev->dev, "internal buffer size error\n");
1104 static void free_usb_related_resources(struct ua101 *ua,
1110 scoped_guard(mutex, &ua->mutex) {
1111 free_stream_urbs(&ua->capture);
1112 free_stream_urbs(&ua->playback);
1114 free_stream_buffers(ua, &ua->capture);
1115 free_stream_buffers(ua, &ua->playback);
1117 for (i = 0; i < ARRAY_SIZE(ua->intf); ++i) {
1118 scoped_guard(mutex, &ua->mutex) {
1119 intf = ua->intf[i];
1120 ua->intf[i] = NULL;
1133 struct ua101 *ua = card->private_data;
1135 mutex_destroy(&ua->mutex);
1150 { /* UA-101 */
1155 { /* UA-1000 */
1162 struct ua101 *ua;
1184 sizeof(*ua), &card);
1188 ua = card->private_data;
1189 ua->dev = interface_to_usbdev(interface);
1190 ua->card = card;
1191 ua->card_index = card_index;
1192 INIT_LIST_HEAD(&ua->midi_list);
1193 spin_lock_init(&ua->lock);
1194 mutex_init(&ua->mutex);
1195 INIT_LIST_HEAD(&ua->ready_playback_urbs);
1196 INIT_WORK(&ua->playback_work, playback_work);
1197 init_waitqueue_head(&ua->alsa_capture_wait);
1198 init_waitqueue_head(&ua->rate_feedback_wait);
1199 init_waitqueue_head(&ua->alsa_playback_wait);
1201 ua->intf[0] = interface;
1202 for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) {
1203 ua->intf[i] = usb_ifnum_to_if(ua->dev,
1205 if (!ua->intf[i]) {
1206 dev_err(&ua->dev->dev, "interface %u not found\n",
1212 ua->intf[i], ua);
1214 ua->intf[i] = NULL;
1220 err = detect_usb_format(ua);
1224 name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101";
1225 strscpy(card->driver, "UA-101");
1227 usb_make_path(ua->dev, usb_path, sizeof(usb_path));
1228 snprintf(ua->card->longname, sizeof(ua->card->longname),
1230 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path,
1231 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full");
1233 err = alloc_stream_buffers(ua, &ua->capture);
1236 err = alloc_stream_buffers(ua, &ua->playback);
1240 err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete);
1243 err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete);
1247 err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm);
1250 ua->pcm->private_data = ua;
1251 strscpy(ua->pcm->name, name);
1252 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops);
1253 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops);
1254 snd_pcm_set_managed_buffer_all(ua->pcm, SNDRV_DMA_TYPE_VMALLOC,
1257 err = snd_usbmidi_create(card, ua->intf[INTF_MIDI],
1258 &ua->midi_list, &midi_quirk);
1266 usb_set_intfdata(interface, ua);
1272 free_usb_related_resources(ua, interface);
1279 struct ua101 *ua = usb_get_intfdata(interface);
1282 if (!ua)
1287 set_bit(DISCONNECTED, &ua->states);
1288 wake_up(&ua->rate_feedback_wait);
1291 snd_card_disconnect(ua->card);
1294 list_for_each(midi, &ua->midi_list)
1296 abort_alsa_playback(ua);
1297 abort_alsa_capture(ua);
1298 scoped_guard(mutex, &ua->mutex) {
1299 stop_usb_playback(ua);
1300 stop_usb_capture(ua);
1303 free_usb_related_resources(ua, interface);
1305 devices_used &= ~(1 << ua->card_index);
1307 snd_card_free_when_closed(ua->card);
1311 { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */
1312 { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */
1313 { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */