Lines Matching refs:ua
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;
180 abort_usb_playback(ua);
181 abort_alsa_playback(ua);
185 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) {
187 spin_lock_irqsave(&ua->lock, flags);
188 list_add_tail(&urb->ready_list, &ua->ready_playback_urbs);
189 if (ua->rate_feedback_count > 0)
190 queue_work(system_highpri_wq, &ua->playback_work);
191 ua->playback.substream->runtime->delay -=
193 ua->playback.frame_bytes;
194 spin_unlock_irqrestore(&ua->lock, flags);
200 struct ua101 *ua = urb->context;
205 set_bit(PLAYBACK_URB_COMPLETED, &ua->states);
206 wake_up(&ua->alsa_playback_wait);
241 static inline void add_with_wraparound(struct ua101 *ua,
245 if (*value >= ua->playback.queue_length)
246 *value -= ua->playback.queue_length;
251 struct ua101 *ua = container_of(work, struct ua101, playback_work);
258 if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
272 spin_lock_irqsave(&ua->lock, flags);
273 while (ua->rate_feedback_count > 0 &&
274 !list_empty(&ua->ready_playback_urbs)) {
276 frames = ua->rate_feedback[ua->rate_feedback_start];
277 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
278 ua->rate_feedback_count--;
281 urb = list_first_entry(&ua->ready_playback_urbs,
287 frames * ua->playback.frame_bytes;
288 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
289 do_period_elapsed |= copy_playback_data(&ua->playback,
299 spin_unlock_irqrestore(&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",
306 ua->playback.substream->runtime->delay += frames;
308 spin_unlock_irqrestore(&ua->lock, flags);
310 snd_pcm_period_elapsed(ua->playback.substream);
348 struct ua101 *ua = urb->context;
349 struct ua101_stream *stream = &ua->capture;
367 spin_lock_irqsave(&ua->lock, flags);
369 if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
374 if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
377 spin_unlock_irqrestore(&ua->lock, flags);
378 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
384 write_ptr = ua->rate_feedback_start;
385 add_with_wraparound(ua, &write_ptr, 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);
399 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
401 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
402 !list_empty(&ua->ready_playback_urbs))
403 queue_work(system_highpri_wq, &ua->playback_work);
406 spin_unlock_irqrestore(&ua->lock, flags);
414 abort_usb_playback(ua);
415 abort_usb_capture(ua);
416 abort_alsa_playback(ua);
417 abort_alsa_capture(ua);
422 struct ua101 *ua = urb->context;
427 set_bit(CAPTURE_URB_COMPLETED, &ua->states);
428 wake_up(&ua->alsa_capture_wait);
431 static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
438 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
455 static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
459 alts = ua->intf[intf_index]->cur_altsetting;
461 int err = usb_set_interface(ua->dev,
464 dev_err(&ua->dev->dev,
473 static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
477 if (!ua->intf[intf_index])
480 alts = ua->intf[intf_index]->cur_altsetting;
482 int err = usb_set_interface(ua->dev,
484 if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
485 dev_warn(&ua->dev->dev,
491 static void stop_usb_capture(struct ua101 *ua)
493 clear_bit(USB_CAPTURE_RUNNING, &ua->states);
495 kill_stream_urbs(&ua->capture);
497 disable_iso_interface(ua, INTF_CAPTURE);
500 static int start_usb_capture(struct ua101 *ua)
504 if (test_bit(DISCONNECTED, &ua->states))
507 if (test_bit(USB_CAPTURE_RUNNING, &ua->states))
510 kill_stream_urbs(&ua->capture);
512 err = enable_iso_interface(ua, INTF_CAPTURE);
516 clear_bit(CAPTURE_URB_COMPLETED, &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;
521 set_bit(USB_CAPTURE_RUNNING, &ua->states);
522 err = submit_stream_urbs(ua, &ua->capture);
524 stop_usb_capture(ua);
528 static void stop_usb_playback(struct ua101 *ua)
530 clear_bit(USB_PLAYBACK_RUNNING, &ua->states);
532 kill_stream_urbs(&ua->playback);
534 cancel_work_sync(&ua->playback_work);
536 disable_iso_interface(ua, INTF_PLAYBACK);
539 static int start_usb_playback(struct ua101 *ua)
545 if (test_bit(DISCONNECTED, &ua->states))
548 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states))
551 kill_stream_urbs(&ua->playback);
552 cancel_work_sync(&ua->playback_work);
554 err = enable_iso_interface(ua, INTF_PLAYBACK);
558 clear_bit(PLAYBACK_URB_COMPLETED, &ua->states);
559 ua->playback.urbs[0]->urb.complete =
561 spin_lock_irq(&ua->lock);
562 INIT_LIST_HEAD(&ua->ready_playback_urbs);
563 spin_unlock_irq(&ua->lock);
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);
577 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
578 stop_usb_playback(ua);
582 for (i = 0; i < ua->playback.queue_length; ++i) {
584 spin_lock_irq(&ua->lock);
585 frames = ua->rate_feedback[ua->rate_feedback_start];
586 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
587 ua->rate_feedback_count--;
588 spin_unlock_irq(&ua->lock);
589 urb = &ua->playback.urbs[i]->urb;
591 frames * ua->playback.frame_bytes;
596 set_bit(USB_PLAYBACK_RUNNING, &ua->states);
597 err = submit_stream_urbs(ua, &ua->playback);
599 stop_usb_playback(ua);
603 static void abort_alsa_capture(struct ua101 *ua)
605 if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
606 snd_pcm_stop_xrun(ua->capture.substream);
609 static void abort_alsa_playback(struct ua101 *ua)
611 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
612 snd_pcm_stop_xrun(ua->playback.substream);
615 static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream,
627 substream->runtime->hw.formats = ua->format_bit;
628 substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate);
629 substream->runtime->hw.rate_min = ua->rate;
630 substream->runtime->hw.rate_max = ua->rate;
640 1500000 / ua->packets_per_second,
650 struct ua101 *ua = substream->private_data;
653 ua->capture.substream = substream;
654 err = set_stream_hw(ua, substream, ua->capture.channels);
658 DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second);
661 mutex_lock(&ua->mutex);
662 err = start_usb_capture(ua);
664 set_bit(ALSA_CAPTURE_OPEN, &ua->states);
665 mutex_unlock(&ua->mutex);
671 struct ua101 *ua = substream->private_data;
674 ua->playback.substream = substream;
675 err = set_stream_hw(ua, substream, ua->playback.channels);
679 DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length,
680 ua->packets_per_second);
682 mutex_lock(&ua->mutex);
683 err = start_usb_capture(ua);
686 err = start_usb_playback(ua);
688 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
689 stop_usb_capture(ua);
692 set_bit(ALSA_PLAYBACK_OPEN, &ua->states);
694 mutex_unlock(&ua->mutex);
700 struct ua101 *ua = substream->private_data;
702 mutex_lock(&ua->mutex);
703 clear_bit(ALSA_CAPTURE_OPEN, &ua->states);
704 if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states))
705 stop_usb_capture(ua);
706 mutex_unlock(&ua->mutex);
712 struct ua101 *ua = substream->private_data;
714 mutex_lock(&ua->mutex);
715 stop_usb_playback(ua);
716 clear_bit(ALSA_PLAYBACK_OPEN, &ua->states);
717 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
718 stop_usb_capture(ua);
719 mutex_unlock(&ua->mutex);
726 struct ua101 *ua = substream->private_data;
729 mutex_lock(&ua->mutex);
730 err = start_usb_capture(ua);
731 mutex_unlock(&ua->mutex);
738 struct ua101 *ua = substream->private_data;
741 mutex_lock(&ua->mutex);
742 err = start_usb_capture(ua);
744 err = start_usb_playback(ua);
745 mutex_unlock(&ua->mutex);
751 struct ua101 *ua = substream->private_data;
754 mutex_lock(&ua->mutex);
755 err = start_usb_capture(ua);
756 mutex_unlock(&ua->mutex);
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))
771 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
774 ua->capture.period_pos = 0;
775 ua->capture.buffer_pos = 0;
781 struct ua101 *ua = substream->private_data;
784 mutex_lock(&ua->mutex);
785 err = start_usb_capture(ua);
787 err = start_usb_playback(ua);
788 mutex_unlock(&ua->mutex);
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))
798 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
802 ua->playback.period_pos = 0;
803 ua->playback.buffer_pos = 0;
809 struct ua101 *ua = substream->private_data;
813 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
815 set_bit(ALSA_CAPTURE_RUNNING, &ua->states);
818 clear_bit(ALSA_CAPTURE_RUNNING, &ua->states);
827 struct ua101 *ua = substream->private_data;
831 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
833 set_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
836 clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
843 static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua,
849 spin_lock_irqsave(&ua->lock, flags);
851 spin_unlock_irqrestore(&ua->lock, flags);
857 struct ua101 *ua = subs->private_data;
859 return ua101_pcm_pointer(ua, &ua->capture);
864 struct ua101 *ua = subs->private_data;
866 return ua101_pcm_pointer(ua, &ua->playback);
939 static int detect_usb_format(struct ua101 *ua)
946 fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]);
947 fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]);
953 ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE;
956 ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE;
959 dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n");
963 dev_err(&ua->dev->dev,
970 dev_err(&ua->dev->dev, "sample width is not 24 bits\n");
974 ua->rate = combine_triple(fmt_capture->tSamFreq[0]);
976 if (ua->rate != rate2) {
977 dev_err(&ua->dev->dev,
979 rate2, ua->rate);
983 switch (ua->dev->speed) {
985 ua->packets_per_second = 1000;
988 ua->packets_per_second = 8000;
991 dev_err(&ua->dev->dev, "unknown device speed\n");
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;
1002 epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc;
1004 dev_err(&ua->dev->dev, "invalid capture endpoint\n");
1007 ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd));
1008 ua->capture.max_packet_bytes = usb_endpoint_maxp(epd);
1010 epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc;
1012 dev_err(&ua->dev->dev, "invalid playback endpoint\n");
1015 ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd));
1016 ua->playback.max_packet_bytes = usb_endpoint_maxp(epd);
1020 static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1043 usb_alloc_coherent(ua->dev, size, GFP_KERNEL,
1053 dev_err(&ua->dev->dev, "too many packets\n");
1059 static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1064 usb_free_coherent(ua->dev,
1070 static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
1089 urb->urb.dev = ua->dev;
1097 urb->urb.context = ua;
1110 dev_err(&ua->dev->dev, "internal buffer size error\n");
1124 static void free_usb_related_resources(struct ua101 *ua,
1130 mutex_lock(&ua->mutex);
1131 free_stream_urbs(&ua->capture);
1132 free_stream_urbs(&ua->playback);
1133 mutex_unlock(&ua->mutex);
1134 free_stream_buffers(ua, &ua->capture);
1135 free_stream_buffers(ua, &ua->playback);
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(&ua->mutex);
1153 struct ua101 *ua = card->private_data;
1155 mutex_destroy(&ua->mutex);
1182 struct ua101 *ua;
1206 sizeof(*ua), &card);
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(&ua->midi_list);
1217 spin_lock_init(&ua->lock);
1218 mutex_init(&ua->mutex);
1219 INIT_LIST_HEAD(&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);
1225 ua->intf[0] = interface;
1226 for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) {
1227 ua->intf[i] = usb_ifnum_to_if(ua->dev,
1229 if (!ua->intf[i]) {
1230 dev_err(&ua->dev->dev, "interface %u not found\n",
1236 ua->intf[i], ua);
1238 ua->intf[i] = NULL;
1244 err = detect_usb_format(ua);
1251 usb_make_path(ua->dev, usb_path, sizeof(usb_path));
1252 snprintf(ua->card->longname, sizeof(ua->card->longname),
1254 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path,
1255 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full");
1257 err = alloc_stream_buffers(ua, &ua->capture);
1260 err = alloc_stream_buffers(ua, &ua->playback);
1264 err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete);
1267 err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete);
1271 err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm);
1274 ua->pcm->private_data = ua;
1275 strcpy(ua->pcm->name, name);
1276 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops);
1277 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops);
1278 snd_pcm_set_managed_buffer_all(ua->pcm, SNDRV_DMA_TYPE_VMALLOC,
1281 err = snd_usbmidi_create(card, ua->intf[INTF_MIDI],
1282 &ua->midi_list, &midi_quirk);
1290 usb_set_intfdata(interface, ua);
1297 free_usb_related_resources(ua, interface);
1305 struct ua101 *ua = usb_get_intfdata(interface);
1308 if (!ua)
1313 set_bit(DISCONNECTED, &ua->states);
1314 wake_up(&ua->rate_feedback_wait);
1317 snd_card_disconnect(ua->card);
1320 list_for_each(midi, &ua->midi_list)
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(&ua->mutex);
1329 free_usb_related_resources(ua, interface);
1331 devices_used &= ~(1 << ua->card_index);
1333 snd_card_free_when_closed(ua->card);